1 /* Generated By:JJTree&JavaCC: Do not edit this line. MobisnapSQL.java */
2 package mobisnap.mobile_trx;
3
4 import java.io.* ;
5 import nmp.dbms.JDBC.*;
6
7 public class MobisnapSQL/*@bgen(jjtree)*/implements MobisnapSQLTreeConstants, MobisnapSQLConstants {/*@bgen(jjtree)*/
8 protected static JJTMobisnapSQLState jjtree = new JJTMobisnapSQLState();public static TransactionHandle transaction;
9 public static MSQLNames names;
10 public static mobisnap.common.UIDFactory uids;
11
12 private static MobisnapSQL fint;
13
14 /***
15 * Pre process a mobile transaction, freezing CURSYSDATE and NEWUID expressions
16 *
17 * @param reader Reader to read mobile transaction
18 */
19 public static synchronized String freezeMSQLTrx( String str) throws Exception {
20 StringReader reader = new StringReader( str);
21 if( fint == null)
22 fint = new MobisnapSQL( reader);
23 else
24 MobisnapSQL.ReInit( reader);
25 ASTCompilationUnit cu = MobisnapSQL.CompilationUnit();
26 StringBuffer buf = new StringBuffer();
27 cu.sourceCode( mobisnap.MobisnapConstants.MSQL_ORIGINAL, buf);
28 return buf.toString();
29 }
30
31 static void jjtreeOpenNodeScope(Node n) {
32 ((SimpleNode)n).firstToken = getToken(1);
33 }
34
35 static void jjtreeCloseNodeScope(Node n) {
36 ((SimpleNode)n).lastToken = getToken(0);
37 }
38
39 static final public ASTCompilationUnit CompilationUnit() throws ParseException {
40 /*@bgen(jjtree) CompilationUnit */
41 ASTCompilationUnit jjtn000 = new ASTCompilationUnit(JJTCOMPILATIONUNIT);
42 boolean jjtc000 = true;
43 jjtree.openNodeScope(jjtn000);
44 jjtreeOpenNodeScope(jjtn000);
45 try {
46 PLSQLBlockStatement(true);
47 jjtree.closeNodeScope(jjtn000, true);
48 jjtc000 = false;
49 jjtreeCloseNodeScope(jjtn000);
50 {if (true) return jjtn000;}
51 } catch (Throwable jjte000) {
52 if (jjtc000) {
53 jjtree.clearNodeScope(jjtn000);
54 jjtc000 = false;
55 } else {
56 jjtree.popNode();
57 }
58 if (jjte000 instanceof RuntimeException) {
59 {if (true) throw (RuntimeException)jjte000;}
60 }
61 if (jjte000 instanceof ParseException) {
62 {if (true) throw (ParseException)jjte000;}
63 }
64 {if (true) throw (Error)jjte000;}
65 } finally {
66 if (jjtc000) {
67 jjtree.closeNodeScope(jjtn000, true);
68 jjtreeCloseNodeScope(jjtn000);
69 }
70 }
71 throw new Error("Missing return statement in function");
72 }
73
74 // ---------------------------------------------------------------------------
75 // ---------------------------------------------------------------------------
76 // ---------------- General Productions ---------------------
77 // ---------------------------------------------------------------------------
78 // ---------------------------------------------------------------------------
79 static final public void OracleObjectName() throws ParseException {
80 /*@bgen(jjtree) OracleObjectName */
81 ASTOracleObjectName jjtn000 = new ASTOracleObjectName(JJTORACLEOBJECTNAME);
82 boolean jjtc000 = true;
83 jjtree.openNodeScope(jjtn000);
84 jjtreeOpenNodeScope(jjtn000);
85 try {
86 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
87 case S_IDENTIFIER:
88 jj_consume_token(S_IDENTIFIER);
89 break;
90 case S_QUOTED_IDENTIFIER:
91 jj_consume_token(S_QUOTED_IDENTIFIER);
92 break;
93 default:
94 jj_la1[0] = jj_gen;
95 jj_consume_token(-1);
96 throw new ParseException();
97 }
98 } finally {
99 if (jjtc000) {
100 jjtree.closeNodeScope(jjtn000, true);
101 jjtreeCloseNodeScope(jjtn000);
102 }
103 }
104 }
105
106 static final public ASTRelop Relop() throws ParseException {
107 /*@bgen(jjtree) Relop */
108 ASTRelop jjtn000 = new ASTRelop(JJTRELOP);
109 boolean jjtc000 = true;
110 jjtree.openNodeScope(jjtn000);
111 jjtreeOpenNodeScope(jjtn000);
112 try {
113 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
114 case 153:
115 jj_consume_token(153);
116 jjtree.closeNodeScope(jjtn000, true);
117 jjtc000 = false;
118 jjtreeCloseNodeScope(jjtn000);
119 jjtn000.type = ASTRelop.OP_EQUAL; {if (true) return jjtn000;}
120 break;
121 case 154:
122 jj_consume_token(154);
123 jjtree.closeNodeScope(jjtn000, true);
124 jjtc000 = false;
125 jjtreeCloseNodeScope(jjtn000);
126 jjtn000.type = ASTRelop.OP_NOTEQUAL; {if (true) return jjtn000;}
127 break;
128 case 155:
129 jj_consume_token(155);
130 jjtree.closeNodeScope(jjtn000, true);
131 jjtc000 = false;
132 jjtreeCloseNodeScope(jjtn000);
133 jjtn000.type = ASTRelop.OP_MOREORLESS; {if (true) return jjtn000;}
134 break;
135 case 156:
136 jj_consume_token(156);
137 jjtree.closeNodeScope(jjtn000, true);
138 jjtc000 = false;
139 jjtreeCloseNodeScope(jjtn000);
140 jjtn000.type = ASTRelop.OP_MORE; {if (true) return jjtn000;}
141 break;
142 case 157:
143 jj_consume_token(157);
144 jjtree.closeNodeScope(jjtn000, true);
145 jjtc000 = false;
146 jjtreeCloseNodeScope(jjtn000);
147 jjtn000.type = ASTRelop.OP_MOREEQUAL; {if (true) return jjtn000;}
148 break;
149 case 158:
150 jj_consume_token(158);
151 jjtree.closeNodeScope(jjtn000, true);
152 jjtc000 = false;
153 jjtreeCloseNodeScope(jjtn000);
154 jjtn000.type = ASTRelop.OP_LESS; {if (true) return jjtn000;}
155 break;
156 case 159:
157 jj_consume_token(159);
158 jjtree.closeNodeScope(jjtn000, true);
159 jjtc000 = false;
160 jjtreeCloseNodeScope(jjtn000);
161 jjtn000.type = ASTRelop.OP_LESSEQUAL; {if (true) return jjtn000;}
162 break;
163 default:
164 jj_la1[1] = jj_gen;
165 jj_consume_token(-1);
166 throw new ParseException();
167 }
168 } finally {
169 if (jjtc000) {
170 jjtree.closeNodeScope(jjtn000, true);
171 jjtreeCloseNodeScope(jjtn000);
172 }
173 }
174 throw new Error("Missing return statement in function");
175 }
176
177 static final public ASTMonitorName MonitorName() throws ParseException {
178 /*@bgen(jjtree) MonitorName */
179 ASTMonitorName jjtn000 = new ASTMonitorName(JJTMONITORNAME);
180 boolean jjtc000 = true;
181 jjtree.openNodeScope(jjtn000);
182 jjtreeOpenNodeScope(jjtn000);Token t;
183 try {
184 // user.table.column
185 /* OracleObjectName() [ "." OracleObjectName() ["." OracleObjectName()]]*/
186 t = jj_consume_token(S_IDENTIFIER);
187 jjtn000.s1 = t.image;
188 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
189 case 160:
190 jj_consume_token(160);
191 t = jj_consume_token(S_IDENTIFIER);
192 jjtn000.s2 = t.image;
193 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
194 case 160:
195 jj_consume_token(160);
196 t = jj_consume_token(S_IDENTIFIER);
197 jjtn000.s3 = t.image;
198 break;
199 default:
200 jj_la1[2] = jj_gen;
201 ;
202 }
203 break;
204 default:
205 jj_la1[3] = jj_gen;
206 ;
207 }
208 jjtree.closeNodeScope(jjtn000, true);
209 jjtc000 = false;
210 jjtreeCloseNodeScope(jjtn000);
211 {if (true) return jjtn000;}
212 } finally {
213 if (jjtc000) {
214 jjtree.closeNodeScope(jjtn000, true);
215 jjtreeCloseNodeScope(jjtn000);
216 }
217 }
218 throw new Error("Missing return statement in function");
219 }
220
221 static final public ASTTableColumn TableColumn() throws ParseException {
222 /*@bgen(jjtree) TableColumn */
223 ASTTableColumn jjtn000 = new ASTTableColumn(JJTTABLECOLUMN);
224 boolean jjtc000 = true;
225 jjtree.openNodeScope(jjtn000);
226 jjtreeOpenNodeScope(jjtn000);Token t;
227 try {
228 // user.table.column
229 /* OracleObjectName() [ "." OracleObjectName() ["." OracleObjectName()]]*/
230 t = jj_consume_token(S_IDENTIFIER);
231 jjtn000.s1 = t.image;
232 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
233 case 160:
234 jj_consume_token(160);
235 t = jj_consume_token(S_IDENTIFIER);
236 jjtn000.s2 = t.image;
237 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
238 case 160:
239 jj_consume_token(160);
240 t = jj_consume_token(S_IDENTIFIER);
241 jjtn000.s3 = t.image;
242 break;
243 default:
244 jj_la1[4] = jj_gen;
245 ;
246 }
247 break;
248 default:
249 jj_la1[5] = jj_gen;
250 ;
251 }
252 jjtree.closeNodeScope(jjtn000, true);
253 jjtc000 = false;
254 jjtreeCloseNodeScope(jjtn000);
255 {if (true) return jjtn000;}
256 } finally {
257 if (jjtc000) {
258 jjtree.closeNodeScope(jjtn000, true);
259 jjtreeCloseNodeScope(jjtn000);
260 }
261 }
262 throw new Error("Missing return statement in function");
263 }
264
265 static final public ASTTableReference TableReference() throws ParseException {
266 /*@bgen(jjtree) TableReference */
267 ASTTableReference jjtn000 = new ASTTableReference(JJTTABLEREFERENCE);
268 boolean jjtc000 = true;
269 jjtree.openNodeScope(jjtn000);
270 jjtreeOpenNodeScope(jjtn000);Token t;
271 try {
272 /* OracleObjectName() ["." OracleObjectName()]*/
273 t = jj_consume_token(S_IDENTIFIER);
274 jjtn000.s1 = t.image;
275 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
276 case 160:
277 jj_consume_token(160);
278 t = jj_consume_token(S_IDENTIFIER);
279 jjtn000.s2 = t.image;
280 break;
281 default:
282 jj_la1[6] = jj_gen;
283 ;
284 }
285 jjtree.closeNodeScope(jjtn000, true);
286 jjtc000 = false;
287 jjtreeCloseNodeScope(jjtn000);
288 {if (true) return jjtn000;}
289 } finally {
290 if (jjtc000) {
291 jjtree.closeNodeScope(jjtn000, true);
292 jjtreeCloseNodeScope(jjtn000);
293 }
294 }
295 throw new Error("Missing return statement in function");
296 }
297
298 // ---------------------------------------------------------------------------
299 // ---------------------------------------------------------------------------
300 // ----------- PL-SQL declaration productions start here -----------------
301 // ---------------------------------------------------------------------------
302 // ---------------------------------------------------------------------------
303 static final public void DeclarationSection() throws ParseException {
304 /*@bgen(jjtree) DeclarationSection */
305 ASTDeclarationSection jjtn000 = new ASTDeclarationSection(JJTDECLARATIONSECTION);
306 boolean jjtc000 = true;
307 jjtree.openNodeScope(jjtn000);
308 jjtreeOpenNodeScope(jjtn000);
309 try {
310 jj_consume_token(K_DECLARE);
311 Declarations();
312 } catch (Throwable jjte000) {
313 if (jjtc000) {
314 jjtree.clearNodeScope(jjtn000);
315 jjtc000 = false;
316 } else {
317 jjtree.popNode();
318 }
319 if (jjte000 instanceof RuntimeException) {
320 {if (true) throw (RuntimeException)jjte000;}
321 }
322 if (jjte000 instanceof ParseException) {
323 {if (true) throw (ParseException)jjte000;}
324 }
325 {if (true) throw (Error)jjte000;}
326 } finally {
327 if (jjtc000) {
328 jjtree.closeNodeScope(jjtn000, true);
329 jjtreeCloseNodeScope(jjtn000);
330 }
331 }
332 }
333
334 static final public void Declarations() throws ParseException {
335 /*@bgen(jjtree) Declarations */
336 ASTDeclarations jjtn000 = new ASTDeclarations(JJTDECLARATIONS);
337 boolean jjtc000 = true;
338 jjtree.openNodeScope(jjtn000);
339 jjtreeOpenNodeScope(jjtn000);
340 try {
341 label_1:
342 while (true) {
343 IdentifierDeclaration();
344 jj_consume_token(161);
345 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
346 case S_IDENTIFIER:
347 ;
348 break;
349 default:
350 jj_la1[7] = jj_gen;
351 break label_1;
352 }
353 }
354 } catch (Throwable jjte000) {
355 if (jjtc000) {
356 jjtree.clearNodeScope(jjtn000);
357 jjtc000 = false;
358 } else {
359 jjtree.popNode();
360 }
361 if (jjte000 instanceof RuntimeException) {
362 {if (true) throw (RuntimeException)jjte000;}
363 }
364 if (jjte000 instanceof ParseException) {
365 {if (true) throw (ParseException)jjte000;}
366 }
367 {if (true) throw (Error)jjte000;}
368 } finally {
369 if (jjtc000) {
370 jjtree.closeNodeScope(jjtn000, true);
371 jjtreeCloseNodeScope(jjtn000);
372 }
373 }
374 }
375
376 static final public void IdentifierDeclaration() throws ParseException {
377 /*@bgen(jjtree) IdentifierDeclaration */
378 ASTIdentifierDeclaration jjtn000 = new ASTIdentifierDeclaration(JJTIDENTIFIERDECLARATION);
379 boolean jjtc000 = true;
380 jjtree.openNodeScope(jjtn000);
381 jjtreeOpenNodeScope(jjtn000);Token t;
382 try {
383 t = jj_consume_token(S_IDENTIFIER);
384 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
385 case K_CONSTANT:
386 ConstantDeclaration(t.image);
387 break;
388 case K_BINARY_INTEGER:
389 case K_BOOLEAN:
390 case K_CHAR:
391 case K_COUNTER:
392 case K_DATE:
393 case K_FLOAT:
394 case K_INTEGER:
395 case K_NATURAL:
396 case K_NUMBER:
397 case K_REAL:
398 case K_VARCHAR2:
399 case K_VARCHAR:
400 VariableDeclaration(t.image);
401 break;
402 default:
403 jj_la1[8] = jj_gen;
404 jj_consume_token(-1);
405 throw new ParseException();
406 }
407 } catch (Throwable jjte000) {
408 if (jjtc000) {
409 jjtree.clearNodeScope(jjtn000);
410 jjtc000 = false;
411 } else {
412 jjtree.popNode();
413 }
414 if (jjte000 instanceof RuntimeException) {
415 {if (true) throw (RuntimeException)jjte000;}
416 }
417 if (jjte000 instanceof ParseException) {
418 {if (true) throw (ParseException)jjte000;}
419 }
420 {if (true) throw (Error)jjte000;}
421 } finally {
422 if (jjtc000) {
423 jjtree.closeNodeScope(jjtn000, true);
424 jjtreeCloseNodeScope(jjtn000);
425 }
426 }
427 }
428
429 static final public void CursorDeclaration() throws ParseException {
430 /*@bgen(jjtree) CursorDeclaration */
431 ASTCursorDeclaration jjtn000 = new ASTCursorDeclaration(JJTCURSORDECLARATION);
432 boolean jjtc000 = true;
433 jjtree.openNodeScope(jjtn000);
434 jjtreeOpenNodeScope(jjtn000);
435 try {
436 jj_consume_token(K_CURSOR);
437 jj_consume_token(S_IDENTIFIER);
438 jj_consume_token(K_IS);
439 SelectStatement(null);
440 } catch (Throwable jjte000) {
441 if (jjtc000) {
442 jjtree.clearNodeScope(jjtn000);
443 jjtc000 = false;
444 } else {
445 jjtree.popNode();
446 }
447 if (jjte000 instanceof RuntimeException) {
448 {if (true) throw (RuntimeException)jjte000;}
449 }
450 if (jjte000 instanceof ParseException) {
451 {if (true) throw (ParseException)jjte000;}
452 }
453 {if (true) throw (Error)jjte000;}
454 } finally {
455 if (jjtc000) {
456 jjtree.closeNodeScope(jjtn000, true);
457 jjtreeCloseNodeScope(jjtn000);
458 }
459 }
460 }
461
462 /*
463 void ProcedureDeclaration():
464 {}
465 {
466 "PROCEDURE" <S_IDENTIFIER> [ "(" ParameterList() ")" ]
467 ( ";" // Procedure Specification
468 |
469 "IS" ProcedureBody()
470 )
471 }
472
473 void ProcedureBody():
474 {}
475 {
476 [ Declarations() ]
477 BeginEndBlock( false)
478 }
479
480 void FunctionDeclaration():
481 {}
482 {
483 "FUNCTION" <S_IDENTIFIER> [ "(" ParameterList() ")" ]
484 "RETURN" TypeDeclaration()
485 ( ";" // FunctionSpecification
486 |
487 "IS" FunctionBody()
488 )
489 }
490
491 void FunctionBody():
492 {}
493 {
494 [ Declarations() ]
495 BeginEndBlock( false)
496 }
497
498 void PragmaDeclaration():
499 {}
500 {
501 "PRAGMA" "EXCEPTION_INIT" "(" NumOrID() "," NumOrID() ")"
502 }
503 */
504 static final public void VariableDeclaration(String name) throws ParseException {
505 /*@bgen(jjtree) VariableDeclaration */
506 ASTVariableDeclaration jjtn000 = new ASTVariableDeclaration(JJTVARIABLEDECLARATION);
507 boolean jjtc000 = true;
508 jjtree.openNodeScope(jjtn000);
509 jjtreeOpenNodeScope(jjtn000);
510 try {
511 jjtn000.name = name;
512 jjtn000.td = TypeDeclaration();
513 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
514 case K_NOT:
515 jj_consume_token(K_NOT);
516 jj_consume_token(K_NULL);
517 jjtn000.notnull = true;
518 break;
519 default:
520 jj_la1[9] = jj_gen;
521 ;
522 }
523 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
524 case K_DEFAULT:
525 case 162:
526 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
527 case 162:
528 jj_consume_token(162);
529 break;
530 case K_DEFAULT:
531 jj_consume_token(K_DEFAULT);
532 break;
533 default:
534 jj_la1[10] = jj_gen;
535 jj_consume_token(-1);
536 throw new ParseException();
537 }
538 jjtn000.initValue = PlSqlExpression();
539 break;
540 default:
541 jj_la1[11] = jj_gen;
542 ;
543 }
544 } catch (Throwable jjte000) {
545 if (jjtc000) {
546 jjtree.clearNodeScope(jjtn000);
547 jjtc000 = false;
548 } else {
549 jjtree.popNode();
550 }
551 if (jjte000 instanceof RuntimeException) {
552 {if (true) throw (RuntimeException)jjte000;}
553 }
554 if (jjte000 instanceof ParseException) {
555 {if (true) throw (ParseException)jjte000;}
556 }
557 {if (true) throw (Error)jjte000;}
558 } finally {
559 if (jjtc000) {
560 jjtree.closeNodeScope(jjtn000, true);
561 jjtreeCloseNodeScope(jjtn000);
562 }
563 }
564 }
565
566 static final public void ConstantDeclaration(String name) throws ParseException {
567 /*@bgen(jjtree) ConstantDeclaration */
568 ASTConstantDeclaration jjtn000 = new ASTConstantDeclaration(JJTCONSTANTDECLARATION);
569 boolean jjtc000 = true;
570 jjtree.openNodeScope(jjtn000);
571 jjtreeOpenNodeScope(jjtn000);
572 try {
573 jjtn000.name = name;
574 jj_consume_token(K_CONSTANT);
575 jjtn000.td = TypeDeclaration();
576 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
577 case K_NOT:
578 jj_consume_token(K_NOT);
579 jj_consume_token(K_NULL);
580 jjtn000.notnull = true;
581 break;
582 default:
583 jj_la1[12] = jj_gen;
584 ;
585 }
586 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
587 case K_DEFAULT:
588 case 162:
589 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
590 case 162:
591 jj_consume_token(162);
592 break;
593 case K_DEFAULT:
594 jj_consume_token(K_DEFAULT);
595 break;
596 default:
597 jj_la1[13] = jj_gen;
598 jj_consume_token(-1);
599 throw new ParseException();
600 }
601 jjtn000.initValue = PlSqlExpression();
602 break;
603 default:
604 jj_la1[14] = jj_gen;
605 ;
606 }
607 } catch (Throwable jjte000) {
608 if (jjtc000) {
609 jjtree.clearNodeScope(jjtn000);
610 jjtc000 = false;
611 } else {
612 jjtree.popNode();
613 }
614 if (jjte000 instanceof RuntimeException) {
615 {if (true) throw (RuntimeException)jjte000;}
616 }
617 if (jjte000 instanceof ParseException) {
618 {if (true) throw (ParseException)jjte000;}
619 }
620 {if (true) throw (Error)jjte000;}
621 } finally {
622 if (jjtc000) {
623 jjtree.closeNodeScope(jjtn000, true);
624 jjtreeCloseNodeScope(jjtn000);
625 }
626 }
627 }
628
629 static final public ASTTypeDeclaration TypeDeclaration() throws ParseException {
630 /*@bgen(jjtree) TypeDeclaration */
631 ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(JJTTYPEDECLARATION);
632 boolean jjtc000 = true;
633 jjtree.openNodeScope(jjtn000);
634 jjtreeOpenNodeScope(jjtn000);
635 try {
636 jjtn000.bdtd = BasicDataTypeDeclaration();
637 jjtree.closeNodeScope(jjtn000, true);
638 jjtc000 = false;
639 jjtreeCloseNodeScope(jjtn000);
640 {if (true) return jjtn000;}
641 } catch (Throwable jjte000) {
642 if (jjtc000) {
643 jjtree.clearNodeScope(jjtn000);
644 jjtc000 = false;
645 } else {
646 jjtree.popNode();
647 }
648 if (jjte000 instanceof RuntimeException) {
649 {if (true) throw (RuntimeException)jjte000;}
650 }
651 if (jjte000 instanceof ParseException) {
652 {if (true) throw (ParseException)jjte000;}
653 }
654 {if (true) throw (Error)jjte000;}
655 } finally {
656 if (jjtc000) {
657 jjtree.closeNodeScope(jjtn000, true);
658 jjtreeCloseNodeScope(jjtn000);
659 }
660 }
661 throw new Error("Missing return statement in function");
662 }
663
664 static final public ASTBasicDataTypeDeclaration BasicDataTypeDeclaration() throws ParseException {
665 /*@bgen(jjtree) BasicDataTypeDeclaration */
666 ASTBasicDataTypeDeclaration jjtn000 = new ASTBasicDataTypeDeclaration(JJTBASICDATATYPEDECLARATION);
667 boolean jjtc000 = true;
668 jjtree.openNodeScope(jjtn000);
669 jjtreeOpenNodeScope(jjtn000);Token t;
670 try {
671 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
672 case K_CHAR:
673 case K_COUNTER:
674 case K_FLOAT:
675 case K_INTEGER:
676 case K_NATURAL:
677 case K_NUMBER:
678 case K_REAL:
679 case K_VARCHAR2:
680 case K_VARCHAR:
681 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
682 case K_CHAR:
683 jj_consume_token(K_CHAR);
684 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_CHAR ;
685 break;
686 case K_VARCHAR:
687 jj_consume_token(K_VARCHAR);
688 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_VARCHAR ;
689 break;
690 case K_VARCHAR2:
691 jj_consume_token(K_VARCHAR2);
692 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_VARCHAR2 ;
693 break;
694 case K_INTEGER:
695 jj_consume_token(K_INTEGER);
696 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_INTEGER ;
697 break;
698 case K_NUMBER:
699 jj_consume_token(K_NUMBER);
700 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_NUMBER ;
701 break;
702 case K_NATURAL:
703 jj_consume_token(K_NATURAL);
704 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_NATURAL ;
705 break;
706 case K_REAL:
707 jj_consume_token(K_REAL);
708 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_REAL ;
709 break;
710 case K_FLOAT:
711 jj_consume_token(K_FLOAT);
712 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_FLOAT ;
713 break;
714 case K_COUNTER:
715 jj_consume_token(K_COUNTER);
716 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_COUNTER ;
717 break;
718 default:
719 jj_la1[15] = jj_gen;
720 jj_consume_token(-1);
721 throw new ParseException();
722 }
723 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
724 case 163:
725 jj_consume_token(163);
726 t = jj_consume_token(S_NUMBER);
727 jjtn000.nl = Integer.parseInt( t.image);
728 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
729 case 164:
730 jj_consume_token(164);
731 t = jj_consume_token(S_NUMBER);
732 jjtn000.nl = Integer.parseInt( t.image);
733 break;
734 default:
735 jj_la1[16] = jj_gen;
736 ;
737 }
738 jj_consume_token(165);
739 break;
740 default:
741 jj_la1[17] = jj_gen;
742 ;
743 }
744 break;
745 case K_DATE:
746 jj_consume_token(K_DATE);
747 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_DATE ;
748 break;
749 case K_BINARY_INTEGER:
750 jj_consume_token(K_BINARY_INTEGER);
751 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_BINARY_INTEGER ;
752 break;
753 case K_BOOLEAN:
754 jj_consume_token(K_BOOLEAN);
755 jjtn000.type = ASTBasicDataTypeDeclaration.BDT_BOOLEAN ;
756 break;
757 default:
758 jj_la1[18] = jj_gen;
759 jj_consume_token(-1);
760 throw new ParseException();
761 }
762 jjtree.closeNodeScope(jjtn000, true);
763 jjtc000 = false;
764 jjtreeCloseNodeScope(jjtn000);
765 {if (true) return jjtn000;}
766 } finally {
767 if (jjtc000) {
768 jjtree.closeNodeScope(jjtn000, true);
769 jjtreeCloseNodeScope(jjtn000);
770 }
771 }
772 throw new Error("Missing return statement in function");
773 }
774
775 static final public void ExceptionDeclaration() throws ParseException {
776 /*@bgen(jjtree) ExceptionDeclaration */
777 ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(JJTEXCEPTIONDECLARATION);
778 boolean jjtc000 = true;
779 jjtree.openNodeScope(jjtn000);
780 jjtreeOpenNodeScope(jjtn000);
781 try {
782 jj_consume_token(K_EXCEPTION);
783 } finally {
784 if (jjtc000) {
785 jjtree.closeNodeScope(jjtn000, true);
786 jjtreeCloseNodeScope(jjtn000);
787 }
788 }
789 }
790
791 // ---------------------------------------------------------------------------
792 // ---------------------------------------------------------------------------
793 // ----------- PL-SQL code productions start here -----------------
794 // ---------------------------------------------------------------------------
795 // ---------------------------------------------------------------------------
796 static final public ASTGetReservation GetReservation() throws ParseException {
797 /*@bgen(jjtree) GetReservation */
798 ASTGetReservation jjtn000 = new ASTGetReservation(JJTGETRESERVATION);
799 boolean jjtc000 = true;
800 jjtree.openNodeScope(jjtn000);
801 jjtreeOpenNodeScope(jjtn000);
802 try {
803 if (jj_2_1(2)) {
804 GetEscrowReservation(jjtn000);
805 } else if (jj_2_2(2)) {
806 GetSlotReservation(jjtn000);
807 } else if (jj_2_3(2)) {
808 GetValueUseReservation(jjtn000);
809 } else {
810 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
811 case K_GET:
812 GetValueChangeReservation(jjtn000);
813 break;
814 default:
815 jj_la1[19] = jj_gen;
816 jj_consume_token(-1);
817 throw new ParseException();
818 }
819 }
820 jjtree.closeNodeScope(jjtn000, true);
821 jjtc000 = false;
822 jjtreeCloseNodeScope(jjtn000);
823 {if (true) return jjtn000;}
824 } catch (Throwable jjte000) {
825 if (jjtc000) {
826 jjtree.clearNodeScope(jjtn000);
827 jjtc000 = false;
828 } else {
829 jjtree.popNode();
830 }
831 if (jjte000 instanceof RuntimeException) {
832 {if (true) throw (RuntimeException)jjte000;}
833 }
834 if (jjte000 instanceof ParseException) {
835 {if (true) throw (ParseException)jjte000;}
836 }
837 {if (true) throw (Error)jjte000;}
838 } finally {
839 if (jjtc000) {
840 jjtree.closeNodeScope(jjtn000, true);
841 jjtreeCloseNodeScope(jjtn000);
842 }
843 }
844 throw new Error("Missing return statement in function");
845 }
846
847 static final public void GetEscrowReservation(ASTGetReservation res) throws ParseException {
848 /*@bgen(jjtree) GetEscrowReservation */
849 ASTGetEscrowReservation jjtn000 = new ASTGetEscrowReservation(JJTGETESCROWRESERVATION);
850 boolean jjtc000 = true;
851 jjtree.openNodeScope(jjtn000);
852 jjtreeOpenNodeScope(jjtn000);
853 try {
854 jj_consume_token(K_GET);
855 jj_consume_token(K_ESCROW);
856 res.type = mobisnap.MobisnapConstants.RSV_ESCROW;
857 jj_consume_token(K_RESERVATION);
858 res.columnname = TableColumn();
859 jj_consume_token(K_FROM);
860 res.tablename = TableReference();
861 jj_consume_token(K_WHERE);
862 RowSpecification(res);
863 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
864 case K_DURING:
865 case K_EXPIRES:
866 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
867 case K_DURING:
868 jj_consume_token(K_DURING);
869 res.duration = PlSqlSimpleExpression();
870 break;
871 case K_EXPIRES:
872 jj_consume_token(K_EXPIRES);
873 res.expires = PlSqlSimpleExpression();
874 break;
875 default:
876 jj_la1[20] = jj_gen;
877 jj_consume_token(-1);
878 throw new ParseException();
879 }
880 break;
881 default:
882 jj_la1[21] = jj_gen;
883 ;
884 }
885 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
886 case K_INSTANCES:
887 jj_consume_token(K_INSTANCES);
888 res.instances = PlSqlSimpleExpression();
889 break;
890 default:
891 jj_la1[22] = jj_gen;
892 ;
893 }
894 } catch (Throwable jjte000) {
895 if (jjtc000) {
896 jjtree.clearNodeScope(jjtn000);
897 jjtc000 = false;
898 } else {
899 jjtree.popNode();
900 }
901 if (jjte000 instanceof RuntimeException) {
902 {if (true) throw (RuntimeException)jjte000;}
903 }
904 if (jjte000 instanceof ParseException) {
905 {if (true) throw (ParseException)jjte000;}
906 }
907 {if (true) throw (Error)jjte000;}
908 } finally {
909 if (jjtc000) {
910 jjtree.closeNodeScope(jjtn000, true);
911 jjtreeCloseNodeScope(jjtn000);
912 }
913 }
914 }
915
916 static final public void GetSlotReservation(ASTGetReservation res) throws ParseException {
917 /*@bgen(jjtree) GetSlotReservation */
918 ASTGetSlotReservation jjtn000 = new ASTGetSlotReservation(JJTGETSLOTRESERVATION);
919 boolean jjtc000 = true;
920 jjtree.openNodeScope(jjtn000);
921 jjtreeOpenNodeScope(jjtn000);
922 try {
923 jj_consume_token(K_GET);
924 jj_consume_token(K_SLOT);
925 res.type = mobisnap.MobisnapConstants.RSV_SLOT;
926 jj_consume_token(K_RESERVATION);
927 RowSpecSlot(res);
928 jj_consume_token(K_FROM);
929 res.tablename = TableReference();
930 jj_consume_token(K_WHERE);
931 RowSpecification(res);
932 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
933 case K_DURING:
934 case K_EXPIRES:
935 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
936 case K_DURING:
937 jj_consume_token(K_DURING);
938 res.duration = PlSqlSimpleExpression();
939 break;
940 case K_EXPIRES:
941 jj_consume_token(K_EXPIRES);
942 res.expires = PlSqlSimpleExpression();
943 break;
944 default:
945 jj_la1[23] = jj_gen;
946 jj_consume_token(-1);
947 throw new ParseException();
948 }
949 break;
950 default:
951 jj_la1[24] = jj_gen;
952 ;
953 }
954 } catch (Throwable jjte000) {
955 if (jjtc000) {
956 jjtree.clearNodeScope(jjtn000);
957 jjtc000 = false;
958 } else {
959 jjtree.popNode();
960 }
961 if (jjte000 instanceof RuntimeException) {
962 {if (true) throw (RuntimeException)jjte000;}
963 }
964 if (jjte000 instanceof ParseException) {
965 {if (true) throw (ParseException)jjte000;}
966 }
967 {if (true) throw (Error)jjte000;}
968 } finally {
969 if (jjtc000) {
970 jjtree.closeNodeScope(jjtn000, true);
971 jjtreeCloseNodeScope(jjtn000);
972 }
973 }
974 }
975
976 static final public void GetValueUseReservation(ASTGetReservation res) throws ParseException {
977 /*@bgen(jjtree) GetValueUseReservation */
978 ASTGetValueUseReservation jjtn000 = new ASTGetValueUseReservation(JJTGETVALUEUSERESERVATION);
979 boolean jjtc000 = true;
980 jjtree.openNodeScope(jjtn000);
981 jjtreeOpenNodeScope(jjtn000);
982 try {
983 jj_consume_token(K_GET);
984 jj_consume_token(K_VALUE_USE);
985 res.type = mobisnap.MobisnapConstants.RSV_VALUE_USE;
986 jj_consume_token(K_RESERVATION);
987 res.columnname = TableColumn();
988 jj_consume_token(K_FROM);
989 res.tablename = TableReference();
990 jj_consume_token(K_WHERE);
991 RowSpecification(res);
992 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
993 case K_DURING:
994 case K_EXPIRES:
995 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
996 case K_DURING:
997 jj_consume_token(K_DURING);
998 res.duration = PlSqlSimpleExpression();
999 break;
1000 case K_EXPIRES:
1001 jj_consume_token(K_EXPIRES);
1002 res.expires = PlSqlSimpleExpression();
1003 break;
1004 default:
1005 jj_la1[25] = jj_gen;
1006 jj_consume_token(-1);
1007 throw new ParseException();
1008 }
1009 break;
1010 default:
1011 jj_la1[26] = jj_gen;
1012 ;
1013 }
1014 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1015 case K_VALUE:
1016 jj_consume_token(K_VALUE);
1017 res.value = PlSqlSimpleExpression();
1018 if( res.type != mobisnap.MobisnapConstants.RSV_VALUE_USE)
1019 {if (true) throw new Exception( "Instances can only be used in escrow reservations");}
1020 break;
1021 default:
1022 jj_la1[27] = jj_gen;
1023 ;
1024 }
1025 } catch (Throwable jjte000) {
1026 if (jjtc000) {
1027 jjtree.clearNodeScope(jjtn000);
1028 jjtc000 = false;
1029 } else {
1030 jjtree.popNode();
1031 }
1032 if (jjte000 instanceof RuntimeException) {
1033 {if (true) throw (RuntimeException)jjte000;}
1034 }
1035 if (jjte000 instanceof ParseException) {
1036 {if (true) throw (ParseException)jjte000;}
1037 }
1038 {if (true) throw (Error)jjte000;}
1039 } finally {
1040 if (jjtc000) {
1041 jjtree.closeNodeScope(jjtn000, true);
1042 jjtreeCloseNodeScope(jjtn000);
1043 }
1044 }
1045 }
1046
1047 static final public void GetValueChangeReservation(ASTGetReservation res) throws ParseException {
1048 /*@bgen(jjtree) GetValueChangeReservation */
1049 ASTGetValueChangeReservation jjtn000 = new ASTGetValueChangeReservation(JJTGETVALUECHANGERESERVATION);
1050 boolean jjtc000 = true;
1051 jjtree.openNodeScope(jjtn000);
1052 jjtreeOpenNodeScope(jjtn000);
1053 try {
1054 jj_consume_token(K_GET);
1055 jj_consume_token(K_VALUECHANGE);
1056 res.type = mobisnap.MobisnapConstants.RSV_VALUE_CHANGE;
1057 jj_consume_token(K_RESERVATION);
1058 res.columnname = TableColumn();
1059 jj_consume_token(K_FROM);
1060 res.tablename = TableReference();
1061 jj_consume_token(K_WHERE);
1062 RowSpecification(res);
1063 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1064 case K_DURING:
1065 case K_EXPIRES:
1066 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1067 case K_DURING:
1068 jj_consume_token(K_DURING);
1069 res.duration = PlSqlSimpleExpression();
1070 break;
1071 case K_EXPIRES:
1072 jj_consume_token(K_EXPIRES);
1073 res.expires = PlSqlSimpleExpression();
1074 break;
1075 default:
1076 jj_la1[28] = jj_gen;
1077 jj_consume_token(-1);
1078 throw new ParseException();
1079 }
1080 break;
1081 default:
1082 jj_la1[29] = jj_gen;
1083 ;
1084 }
1085 } catch (Throwable jjte000) {
1086 if (jjtc000) {
1087 jjtree.clearNodeScope(jjtn000);
1088 jjtc000 = false;
1089 } else {
1090 jjtree.popNode();
1091 }
1092 if (jjte000 instanceof RuntimeException) {
1093 {if (true) throw (RuntimeException)jjte000;}
1094 }
1095 if (jjte000 instanceof ParseException) {
1096 {if (true) throw (ParseException)jjte000;}
1097 }
1098 {if (true) throw (Error)jjte000;}
1099 } finally {
1100 if (jjtc000) {
1101 jjtree.closeNodeScope(jjtn000, true);
1102 jjtreeCloseNodeScope(jjtn000);
1103 }
1104 }
1105 }
1106
1107 static final public ASTRowSpecification RowSpecification(ASTGetReservation reservation) throws ParseException {
1108 /*@bgen(jjtree) RowSpecification */
1109 ASTRowSpecification jjtn000 = new ASTRowSpecification(JJTROWSPECIFICATION);
1110 boolean jjtc000 = true;
1111 jjtree.openNodeScope(jjtn000);
1112 jjtreeOpenNodeScope(jjtn000);ASTTableColumn column;
1113 ASTRelop relop;
1114 ASTPlSqlSimpleExpression expr;
1115 try {
1116 column = TableColumn();
1117 relop = Relop();
1118 expr = PlSqlSimpleExpression();
1119 reservation.insert( column, relop, expr);
1120 label_2:
1121 while (true) {
1122 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1123 case K_AND:
1124 ;
1125 break;
1126 default:
1127 jj_la1[30] = jj_gen;
1128 break label_2;
1129 }
1130 jj_consume_token(K_AND);
1131 column = TableColumn();
1132 relop = Relop();
1133 expr = PlSqlSimpleExpression();
1134 reservation.insert( column, relop, expr);
1135 }
1136 jjtree.closeNodeScope(jjtn000, true);
1137 jjtc000 = false;
1138 jjtreeCloseNodeScope(jjtn000);
1139 {if (true) return jjtn000;}
1140 } catch (Throwable jjte000) {
1141 if (jjtc000) {
1142 jjtree.clearNodeScope(jjtn000);
1143 jjtc000 = false;
1144 } else {
1145 jjtree.popNode();
1146 }
1147 if (jjte000 instanceof RuntimeException) {
1148 {if (true) throw (RuntimeException)jjte000;}
1149 }
1150 if (jjte000 instanceof ParseException) {
1151 {if (true) throw (ParseException)jjte000;}
1152 }
1153 {if (true) throw (Error)jjte000;}
1154 } finally {
1155 if (jjtc000) {
1156 jjtree.closeNodeScope(jjtn000, true);
1157 jjtreeCloseNodeScope(jjtn000);
1158 }
1159 }
1160 throw new Error("Missing return statement in function");
1161 }
1162
1163 static final public ASTRowSpecSlot RowSpecSlot(ASTGetReservation reservation) throws ParseException {
1164 /*@bgen(jjtree) RowSpecSlot */
1165 ASTRowSpecSlot jjtn000 = new ASTRowSpecSlot(JJTROWSPECSLOT);
1166 boolean jjtc000 = true;
1167 jjtree.openNodeScope(jjtn000);
1168 jjtreeOpenNodeScope(jjtn000);ASTTableColumn column;
1169 ASTRelop relop;
1170 ASTPlSqlSimpleExpression expr;
1171 try {
1172 column = TableColumn();
1173 relop = Relop();
1174 expr = PlSqlSimpleExpression();
1175 reservation.insertSlot( column, relop, expr);
1176 jj_consume_token(K_AND);
1177 column = TableColumn();
1178 relop = Relop();
1179 expr = PlSqlSimpleExpression();
1180 reservation.insertSlot( column, relop, expr);
1181 jjtree.closeNodeScope(jjtn000, true);
1182 jjtc000 = false;
1183 jjtreeCloseNodeScope(jjtn000);
1184 {if (true) return jjtn000;}
1185 } catch (Throwable jjte000) {
1186 if (jjtc000) {
1187 jjtree.clearNodeScope(jjtn000);
1188 jjtc000 = false;
1189 } else {
1190 jjtree.popNode();
1191 }
1192 if (jjte000 instanceof RuntimeException) {
1193 {if (true) throw (RuntimeException)jjte000;}
1194 }
1195 if (jjte000 instanceof ParseException) {
1196 {if (true) throw (ParseException)jjte000;}
1197 }
1198 {if (true) throw (Error)jjte000;}
1199 } finally {
1200 if (jjtc000) {
1201 jjtree.closeNodeScope(jjtn000, true);
1202 jjtreeCloseNodeScope(jjtn000);
1203 }
1204 }
1205 throw new Error("Missing return statement in function");
1206 }
1207
1208 static final public ASTDatabaseDefinition DatabaseDefinition() throws ParseException {
1209 /*@bgen(jjtree) DatabaseDefinition */
1210 ASTDatabaseDefinition jjtn000 = new ASTDatabaseDefinition(JJTDATABASEDEFINITION);
1211 boolean jjtc000 = true;
1212 jjtree.openNodeScope(jjtn000);
1213 jjtreeOpenNodeScope(jjtn000);
1214 try {
1215 jj_consume_token(K_BEGIN);
1216 label_3:
1217 while (true) {
1218 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1219 case K_CREATE:
1220 case K_DROP:
1221 ;
1222 break;
1223 default:
1224 jj_la1[31] = jj_gen;
1225 break label_3;
1226 }
1227 if (jj_2_4(2)) {
1228 DDLStatement(jjtn000.stats);
1229 } else {
1230 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1231 case K_CREATE:
1232 ClusterIdStatement(jjtn000.stats);
1233 break;
1234 default:
1235 jj_la1[32] = jj_gen;
1236 jj_consume_token(-1);
1237 throw new ParseException();
1238 }
1239 }
1240 }
1241 jj_consume_token(K_END);
1242 jj_consume_token(161);
1243 jjtree.closeNodeScope(jjtn000, true);
1244 jjtc000 = false;
1245 jjtreeCloseNodeScope(jjtn000);
1246 {if (true) return jjtn000;}
1247 } catch (Throwable jjte000) {
1248 if (jjtc000) {
1249 jjtree.clearNodeScope(jjtn000);
1250 jjtc000 = false;
1251 } else {
1252 jjtree.popNode();
1253 }
1254 if (jjte000 instanceof RuntimeException) {
1255 {if (true) throw (RuntimeException)jjte000;}
1256 }
1257 if (jjte000 instanceof ParseException) {
1258 {if (true) throw (ParseException)jjte000;}
1259 }
1260 {if (true) throw (Error)jjte000;}
1261 } finally {
1262 if (jjtc000) {
1263 jjtree.closeNodeScope(jjtn000, true);
1264 jjtreeCloseNodeScope(jjtn000);
1265 }
1266 }
1267 throw new Error("Missing return statement in function");
1268 }
1269
1270 static final public void DDLStatement(java.util.HashMap stats) throws ParseException {
1271 /*@bgen(jjtree) DDLStatement */
1272 ASTDDLStatement jjtn000 = new ASTDDLStatement(JJTDDLSTATEMENT);
1273 boolean jjtc000 = true;
1274 jjtree.openNodeScope(jjtn000);
1275 jjtreeOpenNodeScope(jjtn000);SimpleNode node;
1276 try {
1277 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1278 case K_CREATE:
1279 node = CreateTable(stats);
1280 break;
1281 case K_DROP:
1282 node = DropTable(stats);
1283 break;
1284 default:
1285 jj_la1[33] = jj_gen;
1286 jj_consume_token(-1);
1287 throw new ParseException();
1288 }
1289 } catch (Throwable jjte000) {
1290 if (jjtc000) {
1291 jjtree.clearNodeScope(jjtn000);
1292 jjtc000 = false;
1293 } else {
1294 jjtree.popNode();
1295 }
1296 if (jjte000 instanceof RuntimeException) {
1297 {if (true) throw (RuntimeException)jjte000;}
1298 }
1299 if (jjte000 instanceof ParseException) {
1300 {if (true) throw (ParseException)jjte000;}
1301 }
1302 {if (true) throw (Error)jjte000;}
1303 } finally {
1304 if (jjtc000) {
1305 jjtree.closeNodeScope(jjtn000, true);
1306 jjtreeCloseNodeScope(jjtn000);
1307 }
1308 }
1309 }
1310
1311 static final public void ClusterIdStatement(java.util.HashMap map) throws ParseException {
1312 /*@bgen(jjtree) ClusterIdStatement */
1313 ASTClusterIdStatement jjtn000 = new ASTClusterIdStatement(JJTCLUSTERIDSTATEMENT);
1314 boolean jjtc000 = true;
1315 jjtree.openNodeScope(jjtn000);
1316 jjtreeOpenNodeScope(jjtn000);ASTTableReference table;
1317 ASTTableColumn column;
1318 java.util.ArrayList list = new java.util.ArrayList();
1319 MSQLTable mstable;
1320 try {
1321 jj_consume_token(K_CREATE);
1322 jj_consume_token(K_CLUSTERID);
1323 jj_consume_token(K_ON);
1324 table = TableReference();
1325 mstable = ((ASTCreateTable)map.get( table.tableName())).table;
1326 mstable.addClusterIds( list);
1327 jj_consume_token(K_AS);
1328 jj_consume_token(163);
1329 column = TableColumn();
1330 list.add( mstable.getField( column.columnName()));
1331 label_4:
1332 while (true) {
1333 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1334 case 164:
1335 ;
1336 break;
1337 default:
1338 jj_la1[34] = jj_gen;
1339 break label_4;
1340 }
1341 jj_consume_token(164);
1342 column = TableColumn();
1343 list.add( mstable.getField( column.columnName()));
1344 }
1345 jj_consume_token(165);
1346 jj_consume_token(161);
1347 } catch (Throwable jjte000) {
1348 if (jjtc000) {
1349 jjtree.clearNodeScope(jjtn000);
1350 jjtc000 = false;
1351 } else {
1352 jjtree.popNode();
1353 }
1354 if (jjte000 instanceof RuntimeException) {
1355 {if (true) throw (RuntimeException)jjte000;}
1356 }
1357 if (jjte000 instanceof ParseException) {
1358 {if (true) throw (ParseException)jjte000;}
1359 }
1360 {if (true) throw (Error)jjte000;}
1361 } finally {
1362 if (jjtc000) {
1363 jjtree.closeNodeScope(jjtn000, true);
1364 jjtreeCloseNodeScope(jjtn000);
1365 }
1366 }
1367 }
1368
1369 static final public ASTCreateSnapshot CreateSnapshot() throws ParseException {
1370 /*@bgen(jjtree) CreateSnapshot */
1371 ASTCreateSnapshot jjtn000 = new ASTCreateSnapshot(JJTCREATESNAPSHOT);
1372 boolean jjtc000 = true;
1373 jjtree.openNodeScope(jjtn000);
1374 jjtreeOpenNodeScope(jjtn000);
1375 try {
1376 jj_consume_token(K_CREATE);
1377 jj_consume_token(K_SNAPSHOT);
1378 jjtn000.tablename = TableReference();
1379 jj_consume_token(K_AS);
1380 jjtn000.query = QueryStatement();
1381 jjtree.closeNodeScope(jjtn000, true);
1382 jjtc000 = false;
1383 jjtreeCloseNodeScope(jjtn000);
1384 {if (true) return jjtn000;}
1385 } catch (Throwable jjte000) {
1386 if (jjtc000) {
1387 jjtree.clearNodeScope(jjtn000);
1388 jjtc000 = false;
1389 } else {
1390 jjtree.popNode();
1391 }
1392 if (jjte000 instanceof RuntimeException) {
1393 {if (true) throw (RuntimeException)jjte000;}
1394 }
1395 if (jjte000 instanceof ParseException) {
1396 {if (true) throw (ParseException)jjte000;}
1397 }
1398 {if (true) throw (Error)jjte000;}
1399 } finally {
1400 if (jjtc000) {
1401 jjtree.closeNodeScope(jjtn000, true);
1402 jjtreeCloseNodeScope(jjtn000);
1403 }
1404 }
1405 throw new Error("Missing return statement in function");
1406 }
1407
1408 static final public ASTUpdateSnapshot UpdateSnapshot() throws ParseException {
1409 /*@bgen(jjtree) UpdateSnapshot */
1410 ASTUpdateSnapshot jjtn000 = new ASTUpdateSnapshot(JJTUPDATESNAPSHOT);
1411 boolean jjtc000 = true;
1412 jjtree.openNodeScope(jjtn000);
1413 jjtreeOpenNodeScope(jjtn000);
1414 try {
1415 jj_consume_token(K_UPDATE);
1416 jj_consume_token(K_SNAPSHOT);
1417 jjtn000.tablename = TableReference();
1418 jj_consume_token(K_AS);
1419 jjtn000.query = QueryStatement();
1420 jjtree.closeNodeScope(jjtn000, true);
1421 jjtc000 = false;
1422 jjtreeCloseNodeScope(jjtn000);
1423 {if (true) return jjtn000;}
1424 } catch (Throwable jjte000) {
1425 if (jjtc000) {
1426 jjtree.clearNodeScope(jjtn000);
1427 jjtc000 = false;
1428 } else {
1429 jjtree.popNode();
1430 }
1431 if (jjte000 instanceof RuntimeException) {
1432 {if (true) throw (RuntimeException)jjte000;}
1433 }
1434 if (jjte000 instanceof ParseException) {
1435 {if (true) throw (ParseException)jjte000;}
1436 }
1437 {if (true) throw (Error)jjte000;}
1438 } finally {
1439 if (jjtc000) {
1440 jjtree.closeNodeScope(jjtn000, true);
1441 jjtreeCloseNodeScope(jjtn000);
1442 }
1443 }
1444 throw new Error("Missing return statement in function");
1445 }
1446
1447 static final public ASTCreateMonitor CreateMonitor() throws ParseException {
1448 /*@bgen(jjtree) CreateMonitor */
1449 ASTCreateMonitor jjtn000 = new ASTCreateMonitor(JJTCREATEMONITOR);
1450 boolean jjtc000 = true;
1451 jjtree.openNodeScope(jjtn000);
1452 jjtreeOpenNodeScope(jjtn000);
1453 try {
1454 jj_consume_token(K_CREATE);
1455 jj_consume_token(K_MONITOR);
1456 jjtn000.name = MonitorName();
1457 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1458 case K_DURING:
1459 case K_EXPIRES:
1460 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1461 case K_DURING:
1462 jj_consume_token(K_DURING);
1463 jjtn000.duration = PlSqlSimpleExpression();
1464 break;
1465 case K_EXPIRES:
1466 jj_consume_token(K_EXPIRES);
1467 jjtn000.expires = PlSqlSimpleExpression();
1468 break;
1469 default:
1470 jj_la1[35] = jj_gen;
1471 jj_consume_token(-1);
1472 throw new ParseException();
1473 }
1474 break;
1475 default:
1476 jj_la1[36] = jj_gen;
1477 ;
1478 }
1479 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1480 case K_CHECK:
1481 jj_consume_token(K_CHECK);
1482 jj_consume_token(K_EVERY);
1483 jjtn000.check = PlSqlSimpleExpression();
1484 break;
1485 default:
1486 jj_la1[37] = jj_gen;
1487 ;
1488 }
1489 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1490 case K_ON:
1491 jj_consume_token(K_ON);
1492 jjtn000.select = MonitorQueryStatement();
1493 break;
1494 default:
1495 jj_la1[38] = jj_gen;
1496 ;
1497 }
1498 jj_consume_token(K_WHEN);
1499 jjtn000.when = PlSqlExpression();
1500 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1501 case K_STABLE:
1502 jj_consume_token(K_STABLE);
1503 jj_consume_token(K_AFTER);
1504 jjtn000.stable_count = PlSqlSimpleExpression();
1505 jj_consume_token(K_TIMES);
1506 jj_consume_token(K_EVERY);
1507 jjtn000.stable_every = PlSqlSimpleExpression();
1508 break;
1509 default:
1510 jj_la1[39] = jj_gen;
1511 ;
1512 }
1513 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1514 case K_DELETE:
1515 jj_consume_token(K_DELETE);
1516 jj_consume_token(K_AFTER);
1517 jjtn000.del_count = PlSqlSimpleExpression();
1518 jj_consume_token(K_TIMES);
1519 break;
1520 default:
1521 jj_la1[40] = jj_gen;
1522 ;
1523 }
1524 jjtn000.code = PLSQLBlockStatement(false);
1525 jj_consume_token(161);
1526 } catch (Throwable jjte000) {
1527 if (jjtc000) {
1528 jjtree.clearNodeScope(jjtn000);
1529 jjtc000 = false;
1530 } else {
1531 jjtree.popNode();
1532 }
1533 if (jjte000 instanceof RuntimeException) {
1534 {if (true) throw (RuntimeException)jjte000;}
1535 }
1536 if (jjte000 instanceof ParseException) {
1537 {if (true) throw (ParseException)jjte000;}
1538 }
1539 {if (true) throw (Error)jjte000;}
1540 } finally {
1541 if (jjtc000) {
1542 jjtree.closeNodeScope(jjtn000, true);
1543 jjtreeCloseNodeScope(jjtn000);
1544 }
1545 }
1546 throw new Error("Missing return statement in function");
1547 }
1548
1549 static final public ASTCreateTable CreateTable(java.util.HashMap map) throws ParseException {
1550 /*@bgen(jjtree) CreateTable */
1551 ASTCreateTable jjtn000 = new ASTCreateTable(JJTCREATETABLE);
1552 boolean jjtc000 = true;
1553 jjtree.openNodeScope(jjtn000);
1554 jjtreeOpenNodeScope(jjtn000);
1555 try {
1556 jj_consume_token(K_CREATE);
1557 jj_consume_token(K_TABLE);
1558 jjtn000.tablename = TableReference();
1559 jjtn000.table = new MSQLTable(jjtn000.tableName(mobisnap.MobisnapConstants.MSQL_SERVER));
1560 jj_consume_token(163);
1561 FieldDefinition(jjtn000.table);
1562 label_5:
1563 while (true) {
1564 if (jj_2_5(2)) {
1565 ;
1566 } else {
1567 break label_5;
1568 }
1569 jj_consume_token(164);
1570 FieldDefinition(jjtn000.table);
1571 }
1572 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1573 case 164:
1574 jj_consume_token(164);
1575 TableConstraint(jjtn000.table);
1576 break;
1577 default:
1578 jj_la1[41] = jj_gen;
1579 ;
1580 }
1581 jj_consume_token(165);
1582 jj_consume_token(161);
1583 jjtree.closeNodeScope(jjtn000, true);
1584 jjtc000 = false;
1585 jjtreeCloseNodeScope(jjtn000);
1586 if( map != null) map.put( jjtn000.tablename.tableName(), jjtn000);
1587 {if (true) return jjtn000;}
1588 } catch (Throwable jjte000) {
1589 if (jjtc000) {
1590 jjtree.clearNodeScope(jjtn000);
1591 jjtc000 = false;
1592 } else {
1593 jjtree.popNode();
1594 }
1595 if (jjte000 instanceof RuntimeException) {
1596 {if (true) throw (RuntimeException)jjte000;}
1597 }
1598 if (jjte000 instanceof ParseException) {
1599 {if (true) throw (ParseException)jjte000;}
1600 }
1601 {if (true) throw (Error)jjte000;}
1602 } finally {
1603 if (jjtc000) {
1604 jjtree.closeNodeScope(jjtn000, true);
1605 jjtreeCloseNodeScope(jjtn000);
1606 }
1607 }
1608 throw new Error("Missing return statement in function");
1609 }
1610
1611 static final public ASTDropTable DropTable(java.util.HashMap map) throws ParseException {
1612 /*@bgen(jjtree) DropTable */
1613 ASTDropTable jjtn000 = new ASTDropTable(JJTDROPTABLE);
1614 boolean jjtc000 = true;
1615 jjtree.openNodeScope(jjtn000);
1616 jjtreeOpenNodeScope(jjtn000);ASTTableReference name;
1617 try {
1618 jj_consume_token(K_DROP);
1619 jj_consume_token(K_TABLE);
1620 name = TableReference();
1621 jj_consume_token(161);
1622 jjtree.closeNodeScope(jjtn000, true);
1623 jjtc000 = false;
1624 jjtreeCloseNodeScope(jjtn000);
1625 if( map != null) map.put( "drop-" + name.tableName(), jjtn000);
1626 {if (true) return jjtn000;}
1627 } catch (Throwable jjte000) {
1628 if (jjtc000) {
1629 jjtree.clearNodeScope(jjtn000);
1630 jjtc000 = false;
1631 } else {
1632 jjtree.popNode();
1633 }
1634 if (jjte000 instanceof RuntimeException) {
1635 {if (true) throw (RuntimeException)jjte000;}
1636 }
1637 if (jjte000 instanceof ParseException) {
1638 {if (true) throw (ParseException)jjte000;}
1639 }
1640 {if (true) throw (Error)jjte000;}
1641 } finally {
1642 if (jjtc000) {
1643 jjtree.closeNodeScope(jjtn000, true);
1644 jjtreeCloseNodeScope(jjtn000);
1645 }
1646 }
1647 throw new Error("Missing return statement in function");
1648 }
1649
1650 static final public ASTFieldDefinition FieldDefinition(MSQLTable table) throws ParseException {
1651 /*@bgen(jjtree) FieldDefinition */
1652 ASTFieldDefinition jjtn000 = new ASTFieldDefinition(JJTFIELDDEFINITION);
1653 boolean jjtc000 = true;
1654 jjtree.openNodeScope(jjtn000);
1655 jjtreeOpenNodeScope(jjtn000);Token t;
1656 MSQLTableField field;
1657 try {
1658 t = jj_consume_token(S_IDENTIFIER);
1659 field = new MSQLTableField( t.image);
1660 field.type = TypeDeclaration();
1661 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1662 case K_CONSTRAINT:
1663 FieldConstraint(field);
1664 break;
1665 default:
1666 jj_la1[42] = jj_gen;
1667 ;
1668 }
1669 jjtree.closeNodeScope(jjtn000, true);
1670 jjtc000 = false;
1671 jjtreeCloseNodeScope(jjtn000);
1672 table.addField(field); {if (true) return jjtn000;}
1673 } catch (Throwable jjte000) {
1674 if (jjtc000) {
1675 jjtree.clearNodeScope(jjtn000);
1676 jjtc000 = false;
1677 } else {
1678 jjtree.popNode();
1679 }
1680 if (jjte000 instanceof RuntimeException) {
1681 {if (true) throw (RuntimeException)jjte000;}
1682 }
1683 if (jjte000 instanceof ParseException) {
1684 {if (true) throw (ParseException)jjte000;}
1685 }
1686 {if (true) throw (Error)jjte000;}
1687 } finally {
1688 if (jjtc000) {
1689 jjtree.closeNodeScope(jjtn000, true);
1690 jjtreeCloseNodeScope(jjtn000);
1691 }
1692 }
1693 throw new Error("Missing return statement in function");
1694 }
1695
1696 static final public ASTTableConstraint TableConstraint(MSQLTable table) throws ParseException {
1697 /*@bgen(jjtree) TableConstraint */
1698 ASTTableConstraint jjtn000 = new ASTTableConstraint(JJTTABLECONSTRAINT);
1699 boolean jjtc000 = true;
1700 jjtree.openNodeScope(jjtn000);
1701 jjtreeOpenNodeScope(jjtn000);MSQLTableConstraint cons = new MSQLTableConstraint();
1702 try {
1703 jj_consume_token(K_CONSTRAINT);
1704 jj_consume_token(S_IDENTIFIER);
1705 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1706 case K_PRIMARY:
1707 jj_consume_token(K_PRIMARY);
1708 jj_consume_token(K_KEY);
1709 FieldList(cons);
1710 cons.primarykey = true;
1711 break;
1712 case 166:
1713 jj_consume_token(166);
1714 FieldList(cons);
1715 cons.notnull = true;
1716 break;
1717 case K_UNIQUE:
1718 jj_consume_token(K_UNIQUE);
1719 FieldList(cons);
1720 cons.unique = true;
1721 break;
1722 default:
1723 jj_la1[43] = jj_gen;
1724 jj_consume_token(-1);
1725 throw new ParseException();
1726 }
1727 jjtree.closeNodeScope(jjtn000, true);
1728 jjtc000 = false;
1729 jjtreeCloseNodeScope(jjtn000);
1730 table.addConstraint( cons); {if (true) return jjtn000;}
1731 } catch (Throwable jjte000) {
1732 if (jjtc000) {
1733 jjtree.clearNodeScope(jjtn000);
1734 jjtc000 = false;
1735 } else {
1736 jjtree.popNode();
1737 }
1738 if (jjte000 instanceof RuntimeException) {
1739 {if (true) throw (RuntimeException)jjte000;}
1740 }
1741 if (jjte000 instanceof ParseException) {
1742 {if (true) throw (ParseException)jjte000;}
1743 }
1744 {if (true) throw (Error)jjte000;}
1745 } finally {
1746 if (jjtc000) {
1747 jjtree.closeNodeScope(jjtn000, true);
1748 jjtreeCloseNodeScope(jjtn000);
1749 }
1750 }
1751 throw new Error("Missing return statement in function");
1752 }
1753
1754 static final public ASTFieldConstraint FieldConstraint(MSQLTableField field) throws ParseException {
1755 /*@bgen(jjtree) FieldConstraint */
1756 ASTFieldConstraint jjtn000 = new ASTFieldConstraint(JJTFIELDCONSTRAINT);
1757 boolean jjtc000 = true;
1758 jjtree.openNodeScope(jjtn000);
1759 jjtreeOpenNodeScope(jjtn000);
1760 try {
1761 jj_consume_token(K_CONSTRAINT);
1762 jj_consume_token(S_IDENTIFIER);
1763 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1764 case K_PRIMARY:
1765 jj_consume_token(K_PRIMARY);
1766 jj_consume_token(K_KEY);
1767 field.primarykey = true;
1768 break;
1769 case 166:
1770 jj_consume_token(166);
1771 field.notnull = true;
1772 break;
1773 case K_UNIQUE:
1774 jj_consume_token(K_UNIQUE);
1775 field.unique = true;
1776 break;
1777 default:
1778 jj_la1[44] = jj_gen;
1779 jj_consume_token(-1);
1780 throw new ParseException();
1781 }
1782 jjtree.closeNodeScope(jjtn000, true);
1783 jjtc000 = false;
1784 jjtreeCloseNodeScope(jjtn000);
1785 {if (true) return jjtn000;}
1786 } finally {
1787 if (jjtc000) {
1788 jjtree.closeNodeScope(jjtn000, true);
1789 jjtreeCloseNodeScope(jjtn000);
1790 }
1791 }
1792 throw new Error("Missing return statement in function");
1793 }
1794
1795 static final public ASTFieldList FieldList(MSQLTableConstraint cons) throws ParseException {
1796 /*@bgen(jjtree) FieldList */
1797 ASTFieldList jjtn000 = new ASTFieldList(JJTFIELDLIST);
1798 boolean jjtc000 = true;
1799 jjtree.openNodeScope(jjtn000);
1800 jjtreeOpenNodeScope(jjtn000);Token t;
1801 try {
1802 jj_consume_token(163);
1803 t = jj_consume_token(S_IDENTIFIER);
1804 cons.addField(t.image);
1805 label_6:
1806 while (true) {
1807 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1808 case 164:
1809 ;
1810 break;
1811 default:
1812 jj_la1[45] = jj_gen;
1813 break label_6;
1814 }
1815 jj_consume_token(164);
1816 t = jj_consume_token(S_IDENTIFIER);
1817 cons.addField(t.image);
1818 }
1819 jj_consume_token(165);
1820 jjtree.closeNodeScope(jjtn000, true);
1821 jjtc000 = false;
1822 jjtreeCloseNodeScope(jjtn000);
1823 {if (true) return jjtn000;}
1824 } finally {
1825 if (jjtc000) {
1826 jjtree.closeNodeScope(jjtn000, true);
1827 jjtreeCloseNodeScope(jjtn000);
1828 }
1829 }
1830 throw new Error("Missing return statement in function");
1831 }
1832
1833 static final public void BeginEndBlock(boolean mainblk) throws ParseException {
1834 /*@bgen(jjtree) BeginEndBlock */
1835 ASTBeginEndBlock jjtn000 = new ASTBeginEndBlock(JJTBEGINENDBLOCK);
1836 boolean jjtc000 = true;
1837 jjtree.openNodeScope(jjtn000);
1838 jjtreeOpenNodeScope(jjtn000);
1839 try {
1840 jjtn000.mainblock = mainblk;
1841 jj_consume_token(K_BEGIN);
1842 jjtn000.stats = SequenceOfStatements();
1843 if (jj_2_6(2)) {
1844 jjtn000.commit = OnCommitBlock();
1845 } else {
1846 ;
1847 }
1848 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1849 case K_ON:
1850 jjtn000.rollback = OnRollbackBlock();
1851 break;
1852 default:
1853 jj_la1[46] = jj_gen;
1854 ;
1855 }
1856 jj_consume_token(K_END);
1857 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1858 case S_IDENTIFIER:
1859 jj_consume_token(S_IDENTIFIER);
1860 break;
1861 default:
1862 jj_la1[47] = jj_gen;
1863 ;
1864 }
1865 jj_consume_token(161);
1866 } catch (Throwable jjte000) {
1867 if (jjtc000) {
1868 jjtree.clearNodeScope(jjtn000);
1869 jjtc000 = false;
1870 } else {
1871 jjtree.popNode();
1872 }
1873 if (jjte000 instanceof RuntimeException) {
1874 {if (true) throw (RuntimeException)jjte000;}
1875 }
1876 if (jjte000 instanceof ParseException) {
1877 {if (true) throw (ParseException)jjte000;}
1878 }
1879 {if (true) throw (Error)jjte000;}
1880 } finally {
1881 if (jjtc000) {
1882 jjtree.closeNodeScope(jjtn000, true);
1883 jjtreeCloseNodeScope(jjtn000);
1884 }
1885 }
1886 }
1887
1888 static final public ASTSequenceOfStatements SequenceOfStatements() throws ParseException {
1889 /*@bgen(jjtree) SequenceOfStatements */
1890 ASTSequenceOfStatements jjtn000 = new ASTSequenceOfStatements(JJTSEQUENCEOFSTATEMENTS);
1891 boolean jjtc000 = true;
1892 jjtree.openNodeScope(jjtn000);
1893 jjtreeOpenNodeScope(jjtn000);
1894 try {
1895 label_7:
1896 while (true) {
1897 PLSQLStatement();
1898 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1899 case K_COMMIT:
1900 case K_DELETE:
1901 case K_IF:
1902 case K_INSERT:
1903 case K_NULL:
1904 case K_ROLLBACK:
1905 case K_SELECT:
1906 case K_UPDATE:
1907 case S_IDENTIFIER:
1908 ;
1909 break;
1910 default:
1911 jj_la1[48] = jj_gen;
1912 break label_7;
1913 }
1914 }
1915 jjtree.closeNodeScope(jjtn000, true);
1916 jjtc000 = false;
1917 jjtreeCloseNodeScope(jjtn000);
1918 {if (true) return jjtn000;}
1919 } catch (Throwable jjte000) {
1920 if (jjtc000) {
1921 jjtree.clearNodeScope(jjtn000);
1922 jjtc000 = false;
1923 } else {
1924 jjtree.popNode();
1925 }
1926 if (jjte000 instanceof RuntimeException) {
1927 {if (true) throw (RuntimeException)jjte000;}
1928 }
1929 if (jjte000 instanceof ParseException) {
1930 {if (true) throw (ParseException)jjte000;}
1931 }
1932 {if (true) throw (Error)jjte000;}
1933 } finally {
1934 if (jjtc000) {
1935 jjtree.closeNodeScope(jjtn000, true);
1936 jjtreeCloseNodeScope(jjtn000);
1937 }
1938 }
1939 throw new Error("Missing return statement in function");
1940 }
1941
1942 static final public ASTExceptionBlock ExceptionBlock() throws ParseException {
1943 /*@bgen(jjtree) ExceptionBlock */
1944 ASTExceptionBlock jjtn000 = new ASTExceptionBlock(JJTEXCEPTIONBLOCK);
1945 boolean jjtc000 = true;
1946 jjtree.openNodeScope(jjtn000);
1947 jjtreeOpenNodeScope(jjtn000);
1948 try {
1949 jj_consume_token(K_EXCEPTION);
1950 label_8:
1951 while (true) {
1952 ExceptionHandler();
1953 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1954 case K_WHEN:
1955 ;
1956 break;
1957 default:
1958 jj_la1[49] = jj_gen;
1959 break label_8;
1960 }
1961 }
1962 jjtree.closeNodeScope(jjtn000, true);
1963 jjtc000 = false;
1964 jjtreeCloseNodeScope(jjtn000);
1965 {if (true) return jjtn000;}
1966 } catch (Throwable jjte000) {
1967 if (jjtc000) {
1968 jjtree.clearNodeScope(jjtn000);
1969 jjtc000 = false;
1970 } else {
1971 jjtree.popNode();
1972 }
1973 if (jjte000 instanceof RuntimeException) {
1974 {if (true) throw (RuntimeException)jjte000;}
1975 }
1976 if (jjte000 instanceof ParseException) {
1977 {if (true) throw (ParseException)jjte000;}
1978 }
1979 {if (true) throw (Error)jjte000;}
1980 } finally {
1981 if (jjtc000) {
1982 jjtree.closeNodeScope(jjtn000, true);
1983 jjtreeCloseNodeScope(jjtn000);
1984 }
1985 }
1986 throw new Error("Missing return statement in function");
1987 }
1988
1989 static final public void ExceptionHandler() throws ParseException {
1990 /*@bgen(jjtree) ExceptionHandler */
1991 ASTExceptionHandler jjtn000 = new ASTExceptionHandler(JJTEXCEPTIONHANDLER);
1992 boolean jjtc000 = true;
1993 jjtree.openNodeScope(jjtn000);
1994 jjtreeOpenNodeScope(jjtn000);
1995 try {
1996 jj_consume_token(K_WHEN);
1997 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1998 case S_IDENTIFIER:
1999 jj_consume_token(S_IDENTIFIER);
2000 label_9:
2001 while (true) {
2002 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2003 case K_OR:
2004 ;
2005 break;
2006 default:
2007 jj_la1[50] = jj_gen;
2008 break label_9;
2009 }
2010 jj_consume_token(K_OR);
2011 jj_consume_token(S_IDENTIFIER);
2012 }
2013 break;
2014 case K_OTHERS:
2015 jj_consume_token(K_OTHERS);
2016 break;
2017 default:
2018 jj_la1[51] = jj_gen;
2019 jj_consume_token(-1);
2020 throw new ParseException();
2021 }
2022 jj_consume_token(K_THEN);
2023 SequenceOfStatements();
2024 } catch (Throwable jjte000) {
2025 if (jjtc000) {
2026 jjtree.clearNodeScope(jjtn000);
2027 jjtc000 = false;
2028 } else {
2029 jjtree.popNode();
2030 }
2031 if (jjte000 instanceof RuntimeException) {
2032 {if (true) throw (RuntimeException)jjte000;}
2033 }
2034 if (jjte000 instanceof ParseException) {
2035 {if (true) throw (ParseException)jjte000;}
2036 }
2037 {if (true) throw (Error)jjte000;}
2038 } finally {
2039 if (jjtc000) {
2040 jjtree.closeNodeScope(jjtn000, true);
2041 jjtreeCloseNodeScope(jjtn000);
2042 }
2043 }
2044 }
2045
2046 static final public ASTOnCommitBlock OnCommitBlock() throws ParseException {
2047 /*@bgen(jjtree) OnCommitBlock */
2048 ASTOnCommitBlock jjtn000 = new ASTOnCommitBlock(JJTONCOMMITBLOCK);
2049 boolean jjtc000 = true;
2050 jjtree.openNodeScope(jjtn000);
2051 jjtreeOpenNodeScope(jjtn000);
2052 try {
2053 jj_consume_token(K_ON);
2054 jj_consume_token(K_COMMIT);
2055 SequenceOfStatements();
2056 jjtree.closeNodeScope(jjtn000, true);
2057 jjtc000 = false;
2058 jjtreeCloseNodeScope(jjtn000);
2059 {if (true) return jjtn000;}
2060 } catch (Throwable jjte000) {
2061 if (jjtc000) {
2062 jjtree.clearNodeScope(jjtn000);
2063 jjtc000 = false;
2064 } else {
2065 jjtree.popNode();
2066 }
2067 if (jjte000 instanceof RuntimeException) {
2068 {if (true) throw (RuntimeException)jjte000;}
2069 }
2070 if (jjte000 instanceof ParseException) {
2071 {if (true) throw (ParseException)jjte000;}
2072 }
2073 {if (true) throw (Error)jjte000;}
2074 } finally {
2075 if (jjtc000) {
2076 jjtree.closeNodeScope(jjtn000, true);
2077 jjtreeCloseNodeScope(jjtn000);
2078 }
2079 }
2080 throw new Error("Missing return statement in function");
2081 }
2082
2083 static final public ASTOnRollbackBlock OnRollbackBlock() throws ParseException {
2084 /*@bgen(jjtree) OnRollbackBlock */
2085 ASTOnRollbackBlock jjtn000 = new ASTOnRollbackBlock(JJTONROLLBACKBLOCK);
2086 boolean jjtc000 = true;
2087 jjtree.openNodeScope(jjtn000);
2088 jjtreeOpenNodeScope(jjtn000);
2089 try {
2090 jj_consume_token(K_ON);
2091 jj_consume_token(K_ROLLBACK);
2092 SequenceOfStatements();
2093 jjtree.closeNodeScope(jjtn000, true);
2094 jjtc000 = false;
2095 jjtreeCloseNodeScope(jjtn000);
2096 {if (true) return jjtn000;}
2097 } catch (Throwable jjte000) {
2098 if (jjtc000) {
2099 jjtree.clearNodeScope(jjtn000);
2100 jjtc000 = false;
2101 } else {
2102 jjtree.popNode();
2103 }
2104 if (jjte000 instanceof RuntimeException) {
2105 {if (true) throw (RuntimeException)jjte000;}
2106 }
2107 if (jjte000 instanceof ParseException) {
2108 {if (true) throw (ParseException)jjte000;}
2109 }
2110 {if (true) throw (Error)jjte000;}
2111 } finally {
2112 if (jjtc000) {
2113 jjtree.closeNodeScope(jjtn000, true);
2114 jjtreeCloseNodeScope(jjtn000);
2115 }
2116 }
2117 throw new Error("Missing return statement in function");
2118 }
2119
2120 static final public void PLSQLStatement() throws ParseException {
2121 /*@bgen(jjtree) PLSQLStatement */
2122 ASTPLSQLStatement jjtn000 = new ASTPLSQLStatement(JJTPLSQLSTATEMENT);
2123 boolean jjtc000 = true;
2124 jjtree.openNodeScope(jjtn000);
2125 jjtreeOpenNodeScope(jjtn000);
2126 try {
2127 if (jj_2_7(2147483647)) {
2128 SubroutineCall();
2129 } else {
2130 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2131 case S_IDENTIFIER:
2132 AssignmentStatement();
2133 break;
2134 case K_IF:
2135 IfStatement();
2136 break;
2137 case K_NULL:
2138 NullStatement();
2139 break;
2140 case K_COMMIT:
2141 case K_DELETE:
2142 case K_INSERT:
2143 case K_ROLLBACK:
2144 case K_SELECT:
2145 case K_UPDATE:
2146 SQLStatement();
2147 break;
2148 default:
2149 jj_la1[52] = jj_gen;
2150 jj_consume_token(-1);
2151 throw new ParseException();
2152 }
2153 }
2154 } catch (Throwable jjte000) {
2155 if (jjtc000) {
2156 jjtree.clearNodeScope(jjtn000);
2157 jjtc000 = false;
2158 } else {
2159 jjtree.popNode();
2160 }
2161 if (jjte000 instanceof RuntimeException) {
2162 {if (true) throw (RuntimeException)jjte000;}
2163 }
2164 if (jjte000 instanceof ParseException) {
2165 {if (true) throw (ParseException)jjte000;}
2166 }
2167 {if (true) throw (Error)jjte000;}
2168 } finally {
2169 if (jjtc000) {
2170 jjtree.closeNodeScope(jjtn000, true);
2171 jjtreeCloseNodeScope(jjtn000);
2172 }
2173 }
2174 }
2175
2176 static final public ASTPLSQLBlockStatement PLSQLBlockStatement(boolean mainblk) throws ParseException {
2177 /*@bgen(jjtree) PLSQLBlockStatement */
2178 ASTPLSQLBlockStatement jjtn000 = new ASTPLSQLBlockStatement(JJTPLSQLBLOCKSTATEMENT);
2179 boolean jjtc000 = true;
2180 jjtree.openNodeScope(jjtn000);
2181 jjtreeOpenNodeScope(jjtn000);
2182 try {
2183 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2184 case K_DECLARE:
2185 DeclarationSection();
2186 break;
2187 default:
2188 jj_la1[53] = jj_gen;
2189 ;
2190 }
2191 BeginEndBlock(mainblk);
2192 jjtree.closeNodeScope(jjtn000, true);
2193 jjtc000 = false;
2194 jjtreeCloseNodeScope(jjtn000);
2195 {if (true) return jjtn000;}
2196 } catch (Throwable jjte000) {
2197 if (jjtc000) {
2198 jjtree.clearNodeScope(jjtn000);
2199 jjtc000 = false;
2200 } else {
2201 jjtree.popNode();
2202 }
2203 if (jjte000 instanceof RuntimeException) {
2204 {if (true) throw (RuntimeException)jjte000;}
2205 }
2206 if (jjte000 instanceof ParseException) {
2207 {if (true) throw (ParseException)jjte000;}
2208 }
2209 {if (true) throw (Error)jjte000;}
2210 } finally {
2211 if (jjtc000) {
2212 jjtree.closeNodeScope(jjtn000, true);
2213 jjtreeCloseNodeScope(jjtn000);
2214 }
2215 }
2216 throw new Error("Missing return statement in function");
2217 }
2218
2219 static final public void LabelDeclaration() throws ParseException {
2220 /*@bgen(jjtree) LabelDeclaration */
2221 ASTLabelDeclaration jjtn000 = new ASTLabelDeclaration(JJTLABELDECLARATION);
2222 boolean jjtc000 = true;
2223 jjtree.openNodeScope(jjtn000);
2224 jjtreeOpenNodeScope(jjtn000);
2225 try {
2226 jj_consume_token(167);
2227 jj_consume_token(S_IDENTIFIER);
2228 jj_consume_token(168);
2229 } finally {
2230 if (jjtc000) {
2231 jjtree.closeNodeScope(jjtn000, true);
2232 jjtreeCloseNodeScope(jjtn000);
2233 }
2234 }
2235 }
2236
2237 static final public void SubroutineCall() throws ParseException {
2238 /*@bgen(jjtree) SubroutineCall */
2239 ASTSubroutineCall jjtn000 = new ASTSubroutineCall(JJTSUBROUTINECALL);
2240 boolean jjtc000 = true;
2241 jjtree.openNodeScope(jjtn000);
2242 jjtreeOpenNodeScope(jjtn000);Token t;
2243 try {
2244 t = jj_consume_token(S_IDENTIFIER);
2245 jjtn000.name = t.image;
2246 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2247 case 163:
2248 jj_consume_token(163);
2249 Arguments(jjtn000.params);
2250 jj_consume_token(165);
2251 break;
2252 default:
2253 jj_la1[54] = jj_gen;
2254 ;
2255 }
2256 jj_consume_token(161);
2257 } catch (Throwable jjte000) {
2258 if (jjtc000) {
2259 jjtree.clearNodeScope(jjtn000);
2260 jjtc000 = false;
2261 } else {
2262 jjtree.popNode();
2263 }
2264 if (jjte000 instanceof RuntimeException) {
2265 {if (true) throw (RuntimeException)jjte000;}
2266 }
2267 if (jjte000 instanceof ParseException) {
2268 {if (true) throw (ParseException)jjte000;}
2269 }
2270 {if (true) throw (Error)jjte000;}
2271 } finally {
2272 if (jjtc000) {
2273 jjtree.closeNodeScope(jjtn000, true);
2274 jjtreeCloseNodeScope(jjtn000);
2275 }
2276 }
2277 }
2278
2279 static final public void AssignmentStatement() throws ParseException {
2280 /*@bgen(jjtree) AssignmentStatement */
2281 ASTAssignmentStatement jjtn000 = new ASTAssignmentStatement(JJTASSIGNMENTSTATEMENT);
2282 boolean jjtc000 = true;
2283 jjtree.openNodeScope(jjtn000);
2284 jjtreeOpenNodeScope(jjtn000);Token t;
2285 try {
2286 t = jj_consume_token(S_IDENTIFIER);
2287 jjtn000.s1 = t.image;
2288 jj_consume_token(162);
2289 jjtn000.expr = PlSqlExpression();
2290 jj_consume_token(161);
2291 } catch (Throwable jjte000) {
2292 if (jjtc000) {
2293 jjtree.clearNodeScope(jjtn000);
2294 jjtc000 = false;
2295 } else {
2296 jjtree.popNode();
2297 }
2298 if (jjte000 instanceof RuntimeException) {
2299 {if (true) throw (RuntimeException)jjte000;}
2300 }
2301 if (jjte000 instanceof ParseException) {
2302 {if (true) throw (ParseException)jjte000;}
2303 }
2304 {if (true) throw (Error)jjte000;}
2305 } finally {
2306 if (jjtc000) {
2307 jjtree.closeNodeScope(jjtn000, true);
2308 jjtreeCloseNodeScope(jjtn000);
2309 }
2310 }
2311 }
2312
2313 static final public void ExitStatement() throws ParseException {
2314 /*@bgen(jjtree) ExitStatement */
2315 ASTExitStatement jjtn000 = new ASTExitStatement(JJTEXITSTATEMENT);
2316 boolean jjtc000 = true;
2317 jjtree.openNodeScope(jjtn000);
2318 jjtreeOpenNodeScope(jjtn000);
2319 try {
2320 jj_consume_token(K_EXIT);
2321 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2322 case S_IDENTIFIER:
2323 jj_consume_token(S_IDENTIFIER);
2324 break;
2325 default:
2326 jj_la1[55] = jj_gen;
2327 ;
2328 }
2329 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2330 case K_WHEN:
2331 jj_consume_token(K_WHEN);
2332 PlSqlExpression();
2333 break;
2334 default:
2335 jj_la1[56] = jj_gen;
2336 ;
2337 }
2338 jj_consume_token(161);
2339 } catch (Throwable jjte000) {
2340 if (jjtc000) {
2341 jjtree.clearNodeScope(jjtn000);
2342 jjtc000 = false;
2343 } else {
2344 jjtree.popNode();
2345 }
2346 if (jjte000 instanceof RuntimeException) {
2347 {if (true) throw (RuntimeException)jjte000;}
2348 }
2349 if (jjte000 instanceof ParseException) {
2350 {if (true) throw (ParseException)jjte000;}
2351 }
2352 {if (true) throw (Error)jjte000;}
2353 } finally {
2354 if (jjtc000) {
2355 jjtree.closeNodeScope(jjtn000, true);
2356 jjtreeCloseNodeScope(jjtn000);
2357 }
2358 }
2359 }
2360
2361 static final public void GotoStatement() throws ParseException {
2362 /*@bgen(jjtree) GotoStatement */
2363 ASTGotoStatement jjtn000 = new ASTGotoStatement(JJTGOTOSTATEMENT);
2364 boolean jjtc000 = true;
2365 jjtree.openNodeScope(jjtn000);
2366 jjtreeOpenNodeScope(jjtn000);
2367 try {
2368 jj_consume_token(K_GOTO);
2369 jj_consume_token(S_IDENTIFIER);
2370 jj_consume_token(161);
2371 } finally {
2372 if (jjtc000) {
2373 jjtree.closeNodeScope(jjtn000, true);
2374 jjtreeCloseNodeScope(jjtn000);
2375 }
2376 }
2377 }
2378
2379 static final public void IfStatement() throws ParseException {
2380 /*@bgen(jjtree) IfStatement */
2381 ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT);
2382 boolean jjtc000 = true;
2383 jjtree.openNodeScope(jjtn000);
2384 jjtreeOpenNodeScope(jjtn000);ASTPlSqlExpression expr;
2385 ASTSequenceOfStatements stats;
2386 try {
2387 jj_consume_token(K_IF);
2388 expr = PlSqlExpression();
2389 jj_consume_token(K_THEN);
2390 stats = SequenceOfStatements();
2391 jjtn000.insert( expr, stats);
2392 label_10:
2393 while (true) {
2394 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2395 case K_ELSIF:
2396 ;
2397 break;
2398 default:
2399 jj_la1[57] = jj_gen;
2400 break label_10;
2401 }
2402 jj_consume_token(K_ELSIF);
2403 expr = PlSqlExpression();
2404 jj_consume_token(K_THEN);
2405 stats = SequenceOfStatements();
2406 jjtn000.insert( expr, stats);
2407 }
2408 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2409 case K_ELSE:
2410 jj_consume_token(K_ELSE);
2411 jjtn000.elseStats = SequenceOfStatements();
2412 break;
2413 default:
2414 jj_la1[58] = jj_gen;
2415 ;
2416 }
2417 jj_consume_token(K_END);
2418 jj_consume_token(K_IF);
2419 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2420 case S_IDENTIFIER:
2421 jj_consume_token(S_IDENTIFIER);
2422 break;
2423 default:
2424 jj_la1[59] = jj_gen;
2425 ;
2426 }
2427 jj_consume_token(161);
2428 } catch (Throwable jjte000) {
2429 if (jjtc000) {
2430 jjtree.clearNodeScope(jjtn000);
2431 jjtc000 = false;
2432 } else {
2433 jjtree.popNode();
2434 }
2435 if (jjte000 instanceof RuntimeException) {
2436 {if (true) throw (RuntimeException)jjte000;}
2437 }
2438 if (jjte000 instanceof ParseException) {
2439 {if (true) throw (ParseException)jjte000;}
2440 }
2441 {if (true) throw (Error)jjte000;}
2442 } finally {
2443 if (jjtc000) {
2444 jjtree.closeNodeScope(jjtn000, true);
2445 jjtreeCloseNodeScope(jjtn000);
2446 }
2447 }
2448 }
2449
2450 static final public void LoopStatement() throws ParseException {
2451 /*@bgen(jjtree) LoopStatement */
2452 ASTLoopStatement jjtn000 = new ASTLoopStatement(JJTLOOPSTATEMENT);
2453 boolean jjtc000 = true;
2454 jjtree.openNodeScope(jjtn000);
2455 jjtreeOpenNodeScope(jjtn000);
2456 try {
2457 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2458 case K_LOOP:
2459 NormalLoop();
2460 break;
2461 case K_WHILE:
2462 WhileLoop();
2463 break;
2464 case K_FOR:
2465 ForLoop();
2466 break;
2467 default:
2468 jj_la1[60] = jj_gen;
2469 jj_consume_token(-1);
2470 throw new ParseException();
2471 }
2472 } catch (Throwable jjte000) {
2473 if (jjtc000) {
2474 jjtree.clearNodeScope(jjtn000);
2475 jjtc000 = false;
2476 } else {
2477 jjtree.popNode();
2478 }
2479 if (jjte000 instanceof RuntimeException) {
2480 {if (true) throw (RuntimeException)jjte000;}
2481 }
2482 if (jjte000 instanceof ParseException) {
2483 {if (true) throw (ParseException)jjte000;}
2484 }
2485 {if (true) throw (Error)jjte000;}
2486 } finally {
2487 if (jjtc000) {
2488 jjtree.closeNodeScope(jjtn000, true);
2489 jjtreeCloseNodeScope(jjtn000);
2490 }
2491 }
2492 }
2493
2494 static final public void NormalLoop() throws ParseException {
2495 /*@bgen(jjtree) NormalLoop */
2496 ASTNormalLoop jjtn000 = new ASTNormalLoop(JJTNORMALLOOP);
2497 boolean jjtc000 = true;
2498 jjtree.openNodeScope(jjtn000);
2499 jjtreeOpenNodeScope(jjtn000);
2500 try {
2501 jj_consume_token(K_LOOP);
2502 SequenceOfStatements();
2503 jj_consume_token(K_END);
2504 jj_consume_token(K_LOOP);
2505 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2506 case S_IDENTIFIER:
2507 jj_consume_token(S_IDENTIFIER);
2508 break;
2509 default:
2510 jj_la1[61] = jj_gen;
2511 ;
2512 }
2513 jj_consume_token(161);
2514 } catch (Throwable jjte000) {
2515 if (jjtc000) {
2516 jjtree.clearNodeScope(jjtn000);
2517 jjtc000 = false;
2518 } else {
2519 jjtree.popNode();
2520 }
2521 if (jjte000 instanceof RuntimeException) {
2522 {if (true) throw (RuntimeException)jjte000;}
2523 }
2524 if (jjte000 instanceof ParseException) {
2525 {if (true) throw (ParseException)jjte000;}
2526 }
2527 {if (true) throw (Error)jjte000;}
2528 } finally {
2529 if (jjtc000) {
2530 jjtree.closeNodeScope(jjtn000, true);
2531 jjtreeCloseNodeScope(jjtn000);
2532 }
2533 }
2534 }
2535
2536 static final public void WhileLoop() throws ParseException {
2537 /*@bgen(jjtree) WhileLoop */
2538 ASTWhileLoop jjtn000 = new ASTWhileLoop(JJTWHILELOOP);
2539 boolean jjtc000 = true;
2540 jjtree.openNodeScope(jjtn000);
2541 jjtreeOpenNodeScope(jjtn000);
2542 try {
2543 jj_consume_token(K_WHILE);
2544 PlSqlExpression();
2545 NormalLoop();
2546 } catch (Throwable jjte000) {
2547 if (jjtc000) {
2548 jjtree.clearNodeScope(jjtn000);
2549 jjtc000 = false;
2550 } else {
2551 jjtree.popNode();
2552 }
2553 if (jjte000 instanceof RuntimeException) {
2554 {if (true) throw (RuntimeException)jjte000;}
2555 }
2556 if (jjte000 instanceof ParseException) {
2557 {if (true) throw (ParseException)jjte000;}
2558 }
2559 {if (true) throw (Error)jjte000;}
2560 } finally {
2561 if (jjtc000) {
2562 jjtree.closeNodeScope(jjtn000, true);
2563 jjtreeCloseNodeScope(jjtn000);
2564 }
2565 }
2566 }
2567
2568 static final public void ForLoop() throws ParseException {
2569 /*@bgen(jjtree) ForLoop */
2570 ASTForLoop jjtn000 = new ASTForLoop(JJTFORLOOP);
2571 boolean jjtc000 = true;
2572 jjtree.openNodeScope(jjtn000);
2573 jjtreeOpenNodeScope(jjtn000);
2574 try {
2575 if (jj_2_8(2147483647)) {
2576 NumericForLoop();
2577 } else {
2578 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2579 case K_FOR:
2580 CursorForLoop();
2581 break;
2582 default:
2583 jj_la1[62] = jj_gen;
2584 jj_consume_token(-1);
2585 throw new ParseException();
2586 }
2587 }
2588 } catch (Throwable jjte000) {
2589 if (jjtc000) {
2590 jjtree.clearNodeScope(jjtn000);
2591 jjtc000 = false;
2592 } else {
2593 jjtree.popNode();
2594 }
2595 if (jjte000 instanceof RuntimeException) {
2596 {if (true) throw (RuntimeException)jjte000;}
2597 }
2598 if (jjte000 instanceof ParseException) {
2599 {if (true) throw (ParseException)jjte000;}
2600 }
2601 {if (true) throw (Error)jjte000;}
2602 } finally {
2603 if (jjtc000) {
2604 jjtree.closeNodeScope(jjtn000, true);
2605 jjtreeCloseNodeScope(jjtn000);
2606 }
2607 }
2608 }
2609
2610 static final public void NumericForLoopLookahead() throws ParseException {
2611 /*@bgen(jjtree) NumericForLoopLookahead */
2612 ASTNumericForLoopLookahead jjtn000 = new ASTNumericForLoopLookahead(JJTNUMERICFORLOOPLOOKAHEAD);
2613 boolean jjtc000 = true;
2614 jjtree.openNodeScope(jjtn000);
2615 jjtreeOpenNodeScope(jjtn000);
2616 try {
2617 jj_consume_token(K_FOR);
2618 jj_consume_token(S_IDENTIFIER);
2619 jj_consume_token(K_IN);
2620 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2621 case K_REVERSE:
2622 jj_consume_token(K_REVERSE);
2623 break;
2624 default:
2625 jj_la1[63] = jj_gen;
2626 ;
2627 }
2628 PlSqlSimpleExpression();
2629 jj_consume_token(169);
2630 } catch (Throwable jjte000) {
2631 if (jjtc000) {
2632 jjtree.clearNodeScope(jjtn000);
2633 jjtc000 = false;
2634 } else {
2635 jjtree.popNode();
2636 }
2637 if (jjte000 instanceof RuntimeException) {
2638 {if (true) throw (RuntimeException)jjte000;}
2639 }
2640 if (jjte000 instanceof ParseException) {
2641 {if (true) throw (ParseException)jjte000;}
2642 }
2643 {if (true) throw (Error)jjte000;}
2644 } finally {
2645 if (jjtc000) {
2646 jjtree.closeNodeScope(jjtn000, true);
2647 jjtreeCloseNodeScope(jjtn000);
2648 }
2649 }
2650 }
2651
2652 static final public void NumericForLoop() throws ParseException {
2653 /*@bgen(jjtree) NumericForLoop */
2654 ASTNumericForLoop jjtn000 = new ASTNumericForLoop(JJTNUMERICFORLOOP);
2655 boolean jjtc000 = true;
2656 jjtree.openNodeScope(jjtn000);
2657 jjtreeOpenNodeScope(jjtn000);
2658 try {
2659 jj_consume_token(K_FOR);
2660 jj_consume_token(S_IDENTIFIER);
2661 jj_consume_token(K_IN);
2662 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2663 case K_REVERSE:
2664 jj_consume_token(K_REVERSE);
2665 break;
2666 default:
2667 jj_la1[64] = jj_gen;
2668 ;
2669 }
2670 PlSqlSimpleExpression();
2671 jj_consume_token(169);
2672 PlSqlSimpleExpression();
2673 NormalLoop();
2674 } catch (Throwable jjte000) {
2675 if (jjtc000) {
2676 jjtree.clearNodeScope(jjtn000);
2677 jjtc000 = false;
2678 } else {
2679 jjtree.popNode();
2680 }
2681 if (jjte000 instanceof RuntimeException) {
2682 {if (true) throw (RuntimeException)jjte000;}
2683 }
2684 if (jjte000 instanceof ParseException) {
2685 {if (true) throw (ParseException)jjte000;}
2686 }
2687 {if (true) throw (Error)jjte000;}
2688 } finally {
2689 if (jjtc000) {
2690 jjtree.closeNodeScope(jjtn000, true);
2691 jjtreeCloseNodeScope(jjtn000);
2692 }
2693 }
2694 }
2695
2696 static final public void CursorForLoop() throws ParseException {
2697 /*@bgen(jjtree) CursorForLoop */
2698 ASTCursorForLoop jjtn000 = new ASTCursorForLoop(JJTCURSORFORLOOP);
2699 boolean jjtc000 = true;
2700 jjtree.openNodeScope(jjtn000);
2701 jjtreeOpenNodeScope(jjtn000);
2702 try {
2703 jj_consume_token(K_FOR);
2704 jj_consume_token(S_IDENTIFIER);
2705 jj_consume_token(K_IN);
2706 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2707 case S_IDENTIFIER:
2708 jj_consume_token(S_IDENTIFIER);
2709 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2710 case 163:
2711 jj_consume_token(163);
2712 Arguments(null);
2713 jj_consume_token(165);
2714 break;
2715 default:
2716 jj_la1[65] = jj_gen;
2717 ;
2718 }
2719 break;
2720 case 163:
2721 jj_consume_token(163);
2722 SelectStatement(null);
2723 jj_consume_token(165);
2724 break;
2725 default:
2726 jj_la1[66] = jj_gen;
2727 jj_consume_token(-1);
2728 throw new ParseException();
2729 }
2730 NormalLoop();
2731 } catch (Throwable jjte000) {
2732 if (jjtc000) {
2733 jjtree.clearNodeScope(jjtn000);
2734 jjtc000 = false;
2735 } else {
2736 jjtree.popNode();
2737 }
2738 if (jjte000 instanceof RuntimeException) {
2739 {if (true) throw (RuntimeException)jjte000;}
2740 }
2741 if (jjte000 instanceof ParseException) {
2742 {if (true) throw (ParseException)jjte000;}
2743 }
2744 {if (true) throw (Error)jjte000;}
2745 } finally {
2746 if (jjtc000) {
2747 jjtree.closeNodeScope(jjtn000, true);
2748 jjtreeCloseNodeScope(jjtn000);
2749 }
2750 }
2751 }
2752
2753 static final public void NullStatement() throws ParseException {
2754 /*@bgen(jjtree) NullStatement */
2755 ASTNullStatement jjtn000 = new ASTNullStatement(JJTNULLSTATEMENT);
2756 boolean jjtc000 = true;
2757 jjtree.openNodeScope(jjtn000);
2758 jjtreeOpenNodeScope(jjtn000);
2759 try {
2760 jj_consume_token(K_NULL);
2761 jj_consume_token(161);
2762 } finally {
2763 if (jjtc000) {
2764 jjtree.closeNodeScope(jjtn000, true);
2765 jjtreeCloseNodeScope(jjtn000);
2766 }
2767 }
2768 }
2769
2770 static final public void RaiseStatement() throws ParseException {
2771 /*@bgen(jjtree) RaiseStatement */
2772 ASTRaiseStatement jjtn000 = new ASTRaiseStatement(JJTRAISESTATEMENT);
2773 boolean jjtc000 = true;
2774 jjtree.openNodeScope(jjtn000);
2775 jjtreeOpenNodeScope(jjtn000);
2776 try {
2777 jj_consume_token(K_RAISE);
2778 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2779 case S_IDENTIFIER:
2780 jj_consume_token(S_IDENTIFIER);
2781 break;
2782 default:
2783 jj_la1[67] = jj_gen;
2784 ;
2785 }
2786 jj_consume_token(161);
2787 } finally {
2788 if (jjtc000) {
2789 jjtree.closeNodeScope(jjtn000, true);
2790 jjtreeCloseNodeScope(jjtn000);
2791 }
2792 }
2793 }
2794
2795 static final public void ReturnStatement() throws ParseException {
2796 /*@bgen(jjtree) ReturnStatement */
2797 ASTReturnStatement jjtn000 = new ASTReturnStatement(JJTRETURNSTATEMENT);
2798 boolean jjtc000 = true;
2799 jjtree.openNodeScope(jjtn000);
2800 jjtreeOpenNodeScope(jjtn000);
2801 try {
2802 jj_consume_token(K_RETURN);
2803 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2804 case K_CURSYSDATE:
2805 case K_NEWUID:
2806 case K_NOT:
2807 case K_NULL:
2808 case K_SYSDATE:
2809 case S_NUMBER:
2810 case S_IDENTIFIER:
2811 case S_CHAR_LITERAL:
2812 case 163:
2813 case 170:
2814 case 171:
2815 PlSqlExpression();
2816 break;
2817 default:
2818 jj_la1[68] = jj_gen;
2819 ;
2820 }
2821 jj_consume_token(161);
2822 } catch (Throwable jjte000) {
2823 if (jjtc000) {
2824 jjtree.clearNodeScope(jjtn000);
2825 jjtc000 = false;
2826 } else {
2827 jjtree.popNode();
2828 }
2829 if (jjte000 instanceof RuntimeException) {
2830 {if (true) throw (RuntimeException)jjte000;}
2831 }
2832 if (jjte000 instanceof ParseException) {
2833 {if (true) throw (ParseException)jjte000;}
2834 }
2835 {if (true) throw (Error)jjte000;}
2836 } finally {
2837 if (jjtc000) {
2838 jjtree.closeNodeScope(jjtn000, true);
2839 jjtreeCloseNodeScope(jjtn000);
2840 }
2841 }
2842 }
2843
2844 static final public void CloseStatement() throws ParseException {
2845 /*@bgen(jjtree) CloseStatement */
2846 ASTCloseStatement jjtn000 = new ASTCloseStatement(JJTCLOSESTATEMENT);
2847 boolean jjtc000 = true;
2848 jjtree.openNodeScope(jjtn000);
2849 jjtreeOpenNodeScope(jjtn000);
2850 try {
2851 jj_consume_token(K_CLOSE);
2852 jj_consume_token(S_IDENTIFIER);
2853 jj_consume_token(161);
2854 } finally {
2855 if (jjtc000) {
2856 jjtree.closeNodeScope(jjtn000, true);
2857 jjtreeCloseNodeScope(jjtn000);
2858 }
2859 }
2860 }
2861
2862 static final public void CommitStatement() throws ParseException {
2863 /*@bgen(jjtree) CommitStatement */
2864 ASTCommitStatement jjtn000 = new ASTCommitStatement(JJTCOMMITSTATEMENT);
2865 boolean jjtc000 = true;
2866 jjtree.openNodeScope(jjtn000);
2867 jjtreeOpenNodeScope(jjtn000);
2868 try {
2869 jj_consume_token(K_COMMIT);
2870 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2871 case K_WORK:
2872 jj_consume_token(K_WORK);
2873 break;
2874 default:
2875 jj_la1[69] = jj_gen;
2876 ;
2877 }
2878 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2879 case K_COMMENT:
2880 jj_consume_token(K_COMMENT);
2881 jj_consume_token(S_CHAR_LITERAL);
2882 break;
2883 default:
2884 jj_la1[70] = jj_gen;
2885 ;
2886 }
2887 jj_consume_token(161);
2888 } finally {
2889 if (jjtc000) {
2890 jjtree.closeNodeScope(jjtn000, true);
2891 jjtreeCloseNodeScope(jjtn000);
2892 }
2893 }
2894 }
2895
2896 static final public void FetchStatement() throws ParseException {
2897 /*@bgen(jjtree) FetchStatement */
2898 ASTFetchStatement jjtn000 = new ASTFetchStatement(JJTFETCHSTATEMENT);
2899 boolean jjtc000 = true;
2900 jjtree.openNodeScope(jjtn000);
2901 jjtreeOpenNodeScope(jjtn000);
2902 try {
2903 jj_consume_token(K_FETCH);
2904 jj_consume_token(S_IDENTIFIER);
2905 jj_consume_token(K_INTO);
2906 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2907 case S_IDENTIFIER:
2908 jj_consume_token(S_IDENTIFIER);
2909 break;
2910 case S_BIND:
2911 jj_consume_token(S_BIND);
2912 break;
2913 default:
2914 jj_la1[71] = jj_gen;
2915 jj_consume_token(-1);
2916 throw new ParseException();
2917 }
2918 label_11:
2919 while (true) {
2920 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2921 case 164:
2922 ;
2923 break;
2924 default:
2925 jj_la1[72] = jj_gen;
2926 break label_11;
2927 }
2928 jj_consume_token(164);
2929 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2930 case S_IDENTIFIER:
2931 jj_consume_token(S_IDENTIFIER);
2932 break;
2933 case S_BIND:
2934 jj_consume_token(S_BIND);
2935 break;
2936 default:
2937 jj_la1[73] = jj_gen;
2938 jj_consume_token(-1);
2939 throw new ParseException();
2940 }
2941 }
2942 jj_consume_token(161);
2943 } finally {
2944 if (jjtc000) {
2945 jjtree.closeNodeScope(jjtn000, true);
2946 jjtreeCloseNodeScope(jjtn000);
2947 }
2948 }
2949 }
2950
2951 static final public void LockTableStatement() throws ParseException {
2952 /*@bgen(jjtree) LockTableStatement */
2953 ASTLockTableStatement jjtn000 = new ASTLockTableStatement(JJTLOCKTABLESTATEMENT);
2954 boolean jjtc000 = true;
2955 jjtree.openNodeScope(jjtn000);
2956 jjtreeOpenNodeScope(jjtn000);
2957 try {
2958 jj_consume_token(K_LOCK);
2959 jj_consume_token(K_TABLE);
2960 TableReference();
2961 label_12:
2962 while (true) {
2963 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2964 case 164:
2965 ;
2966 break;
2967 default:
2968 jj_la1[74] = jj_gen;
2969 break label_12;
2970 }
2971 jj_consume_token(164);
2972 TableReference();
2973 }
2974 jj_consume_token(K_IN);
2975 LockMode();
2976 jj_consume_token(K_MODE);
2977 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2978 case K_NOWAIT:
2979 jj_consume_token(K_NOWAIT);
2980 break;
2981 default:
2982 jj_la1[75] = jj_gen;
2983 ;
2984 }
2985 jj_consume_token(161);
2986 } catch (Throwable jjte000) {
2987 if (jjtc000) {
2988 jjtree.clearNodeScope(jjtn000);
2989 jjtc000 = false;
2990 } else {
2991 jjtree.popNode();
2992 }
2993 if (jjte000 instanceof RuntimeException) {
2994 {if (true) throw (RuntimeException)jjte000;}
2995 }
2996 if (jjte000 instanceof ParseException) {
2997 {if (true) throw (ParseException)jjte000;}
2998 }
2999 {if (true) throw (Error)jjte000;}
3000 } finally {
3001 if (jjtc000) {
3002 jjtree.closeNodeScope(jjtn000, true);
3003 jjtreeCloseNodeScope(jjtn000);
3004 }
3005 }
3006 }
3007
3008 static final public void OpenStatement() throws ParseException {
3009 /*@bgen(jjtree) OpenStatement */
3010 ASTOpenStatement jjtn000 = new ASTOpenStatement(JJTOPENSTATEMENT);
3011 boolean jjtc000 = true;
3012 jjtree.openNodeScope(jjtn000);
3013 jjtreeOpenNodeScope(jjtn000);
3014 try {
3015 jj_consume_token(K_OPEN);
3016 jj_consume_token(S_IDENTIFIER);
3017 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3018 case 163:
3019 jj_consume_token(163);
3020 Arguments(null);
3021 jj_consume_token(165);
3022 break;
3023 default:
3024 jj_la1[76] = jj_gen;
3025 ;
3026 }
3027 jj_consume_token(161);
3028 } catch (Throwable jjte000) {
3029 if (jjtc000) {
3030 jjtree.clearNodeScope(jjtn000);
3031 jjtc000 = false;
3032 } else {
3033 jjtree.popNode();
3034 }
3035 if (jjte000 instanceof RuntimeException) {
3036 {if (true) throw (RuntimeException)jjte000;}
3037 }
3038 if (jjte000 instanceof ParseException) {
3039 {if (true) throw (ParseException)jjte000;}
3040 }
3041 {if (true) throw (Error)jjte000;}
3042 } finally {
3043 if (jjtc000) {
3044 jjtree.closeNodeScope(jjtn000, true);
3045 jjtreeCloseNodeScope(jjtn000);
3046 }
3047 }
3048 }
3049
3050 static final public void RollbackStatement() throws ParseException {
3051 /*@bgen(jjtree) RollbackStatement */
3052 ASTRollbackStatement jjtn000 = new ASTRollbackStatement(JJTROLLBACKSTATEMENT);
3053 boolean jjtc000 = true;
3054 jjtree.openNodeScope(jjtn000);
3055 jjtreeOpenNodeScope(jjtn000);
3056 try {
3057 jj_consume_token(K_ROLLBACK);
3058 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3059 case K_WORK:
3060 jj_consume_token(K_WORK);
3061 break;
3062 default:
3063 jj_la1[77] = jj_gen;
3064 ;
3065 }
3066 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3067 case K_TO:
3068 jj_consume_token(K_TO);
3069 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3070 case K_SAVEPOINT:
3071 jj_consume_token(K_SAVEPOINT);
3072 break;
3073 default:
3074 jj_la1[78] = jj_gen;
3075 ;
3076 }
3077 jj_consume_token(S_IDENTIFIER);
3078 break;
3079 default:
3080 jj_la1[79] = jj_gen;
3081 ;
3082 }
3083 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3084 case K_COMMENT:
3085 jj_consume_token(K_COMMENT);
3086 jj_consume_token(S_CHAR_LITERAL);
3087 break;
3088 default:
3089 jj_la1[80] = jj_gen;
3090 ;
3091 }
3092 jj_consume_token(161);
3093 } finally {
3094 if (jjtc000) {
3095 jjtree.closeNodeScope(jjtn000, true);
3096 jjtreeCloseNodeScope(jjtn000);
3097 }
3098 }
3099 }
3100
3101 static final public void SetTransactionStatement() throws ParseException {
3102 /*@bgen(jjtree) SetTransactionStatement */
3103 ASTSetTransactionStatement jjtn000 = new ASTSetTransactionStatement(JJTSETTRANSACTIONSTATEMENT);
3104 boolean jjtc000 = true;
3105 jjtree.openNodeScope(jjtn000);
3106 jjtreeOpenNodeScope(jjtn000);
3107 try {
3108 jj_consume_token(K_SET);
3109 jj_consume_token(K_TRANSACTION);
3110 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3111 case K_READ:
3112 jj_consume_token(K_READ);
3113 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3114 case K_ONLY:
3115 jj_consume_token(K_ONLY);
3116 break;
3117 case K_WRITE:
3118 jj_consume_token(K_WRITE);
3119 break;
3120 default:
3121 jj_la1[81] = jj_gen;
3122 jj_consume_token(-1);
3123 throw new ParseException();
3124 }
3125 break;
3126 case K_USE:
3127 jj_consume_token(K_USE);
3128 jj_consume_token(K_ROLLBACK);
3129 jj_consume_token(K_SEGMENT);
3130 jj_consume_token(S_IDENTIFIER);
3131 break;
3132 default:
3133 jj_la1[82] = jj_gen;
3134 jj_consume_token(-1);
3135 throw new ParseException();
3136 }
3137 jj_consume_token(161);
3138 } finally {
3139 if (jjtc000) {
3140 jjtree.closeNodeScope(jjtn000, true);
3141 jjtreeCloseNodeScope(jjtn000);
3142 }
3143 }
3144 }
3145
3146 static final public void LockMode() throws ParseException {
3147 /*@bgen(jjtree) LockMode */
3148 ASTLockMode jjtn000 = new ASTLockMode(JJTLOCKMODE);
3149 boolean jjtc000 = true;
3150 jjtree.openNodeScope(jjtn000);
3151 jjtreeOpenNodeScope(jjtn000);
3152 try {
3153 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3154 case K_ROW:
3155 jj_consume_token(K_ROW);
3156 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3157 case K_SHARE:
3158 jj_consume_token(K_SHARE);
3159 break;
3160 case K_EXCLUSIVE:
3161 jj_consume_token(K_EXCLUSIVE);
3162 break;
3163 default:
3164 jj_la1[83] = jj_gen;
3165 jj_consume_token(-1);
3166 throw new ParseException();
3167 }
3168 break;
3169 case K_SHARE:
3170 jj_consume_token(K_SHARE);
3171 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3172 case K_ROW:
3173 case K_UPDATE:
3174 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3175 case K_UPDATE:
3176 jj_consume_token(K_UPDATE);
3177 break;
3178 case K_ROW:
3179 jj_consume_token(K_ROW);
3180 jj_consume_token(K_EXCLUSIVE);
3181 break;
3182 default:
3183 jj_la1[84] = jj_gen;
3184 jj_consume_token(-1);
3185 throw new ParseException();
3186 }
3187 break;
3188 default:
3189 jj_la1[85] = jj_gen;
3190 ;
3191 }
3192 break;
3193 case K_EXCLUSIVE:
3194 jj_consume_token(K_EXCLUSIVE);
3195 break;
3196 default:
3197 jj_la1[86] = jj_gen;
3198 jj_consume_token(-1);
3199 throw new ParseException();
3200 }
3201 } finally {
3202 if (jjtc000) {
3203 jjtree.closeNodeScope(jjtn000, true);
3204 jjtreeCloseNodeScope(jjtn000);
3205 }
3206 }
3207 }
3208
3209 static final public void SavepointStatement() throws ParseException {
3210 /*@bgen(jjtree) SavepointStatement */
3211 ASTSavepointStatement jjtn000 = new ASTSavepointStatement(JJTSAVEPOINTSTATEMENT);
3212 boolean jjtc000 = true;
3213 jjtree.openNodeScope(jjtn000);
3214 jjtreeOpenNodeScope(jjtn000);
3215 try {
3216 jj_consume_token(K_SAVEPOINT);
3217 jj_consume_token(S_IDENTIFIER);
3218 jj_consume_token(161);
3219 } finally {
3220 if (jjtc000) {
3221 jjtree.closeNodeScope(jjtn000, true);
3222 jjtreeCloseNodeScope(jjtn000);
3223 }
3224 }
3225 }
3226
3227 static final public void UpdateStatement() throws ParseException {
3228 /*@bgen(jjtree) UpdateStatement */
3229 ASTUpdateStatement jjtn000 = new ASTUpdateStatement(JJTUPDATESTATEMENT);
3230 boolean jjtc000 = true;
3231 jjtree.openNodeScope(jjtn000);
3232 jjtreeOpenNodeScope(jjtn000);Token t = null;
3233 try {
3234 jj_consume_token(K_UPDATE);
3235 jjtn000.table = TableReference();
3236 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3237 case S_IDENTIFIER:
3238 t = jj_consume_token(S_IDENTIFIER);
3239 break;
3240 default:
3241 jj_la1[87] = jj_gen;
3242 ;
3243 }
3244 if( t == null)
3245 jjtn000.tableId = "";
3246 else
3247 jjtn000.tableId = t.image.trim();
3248 jj_consume_token(K_SET);
3249 ColumnValues(jjtn000);
3250 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3251 case K_WHERE:
3252 jj_consume_token(K_WHERE);
3253 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3254 case K_CURSYSDATE:
3255 case K_EXISTS:
3256 case K_NEWUID:
3257 case K_NOT:
3258 case K_NULL:
3259 case K_PRIOR:
3260 case K_SYSDATE:
3261 case S_NUMBER:
3262 case S_IDENTIFIER:
3263 case S_BIND:
3264 case S_CHAR_LITERAL:
3265 case S_QUOTED_IDENTIFIER:
3266 case 163:
3267 case 170:
3268 case 171:
3269 jjtn000.where = SQLExpression();
3270 break;
3271 case K_CURRENT:
3272 jj_consume_token(K_CURRENT);
3273 jj_consume_token(K_OF);
3274 jj_consume_token(S_IDENTIFIER);
3275 jjtn000.simpleUpdate = false;
3276 break;
3277 default:
3278 jj_la1[88] = jj_gen;
3279 jj_consume_token(-1);
3280 throw new ParseException();
3281 }
3282 break;
3283 default:
3284 jj_la1[89] = jj_gen;
3285 ;
3286 }
3287 jj_consume_token(161);
3288 } catch (Throwable jjte000) {
3289 if (jjtc000) {
3290 jjtree.clearNodeScope(jjtn000);
3291 jjtc000 = false;
3292 } else {
3293 jjtree.popNode();
3294 }
3295 if (jjte000 instanceof RuntimeException) {
3296 {if (true) throw (RuntimeException)jjte000;}
3297 }
3298 if (jjte000 instanceof ParseException) {
3299 {if (true) throw (ParseException)jjte000;}
3300 }
3301 {if (true) throw (Error)jjte000;}
3302 } finally {
3303 if (jjtc000) {
3304 jjtree.closeNodeScope(jjtn000, true);
3305 jjtreeCloseNodeScope(jjtn000);
3306 }
3307 }
3308 }
3309
3310 static final public void ColumnValues(ASTUpdateStatement stat) throws ParseException {
3311 /*@bgen(jjtree) ColumnValues */
3312 ASTColumnValues jjtn000 = new ASTColumnValues(JJTCOLUMNVALUES);
3313 boolean jjtc000 = true;
3314 jjtree.openNodeScope(jjtn000);
3315 jjtreeOpenNodeScope(jjtn000);ASTTableColumn column;
3316 try {
3317 column = TableColumn();
3318 jj_consume_token(153);
3319 UpdatedValue(stat, column);
3320 label_13:
3321 while (true) {
3322 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3323 case 164:
3324 ;
3325 break;
3326 default:
3327 jj_la1[90] = jj_gen;
3328 break label_13;
3329 }
3330 jj_consume_token(164);
3331 column = TableColumn();
3332 jj_consume_token(153);
3333 UpdatedValue(stat, column);
3334 }
3335 } catch (Throwable jjte000) {
3336 if (jjtc000) {
3337 jjtree.clearNodeScope(jjtn000);
3338 jjtc000 = false;
3339 } else {
3340 jjtree.popNode();
3341 }
3342 if (jjte000 instanceof RuntimeException) {
3343 {if (true) throw (RuntimeException)jjte000;}
3344 }
3345 if (jjte000 instanceof ParseException) {
3346 {if (true) throw (ParseException)jjte000;}
3347 }
3348 {if (true) throw (Error)jjte000;}
3349 } finally {
3350 if (jjtc000) {
3351 jjtree.closeNodeScope(jjtn000, true);
3352 jjtreeCloseNodeScope(jjtn000);
3353 }
3354 }
3355 }
3356
3357 static final public void UpdatedValue(ASTUpdateStatement stat, ASTTableColumn col) throws ParseException {
3358 /*@bgen(jjtree) UpdatedValue */
3359 ASTUpdatedValue jjtn000 = new ASTUpdatedValue(JJTUPDATEDVALUE);
3360 boolean jjtc000 = true;
3361 jjtree.openNodeScope(jjtn000);
3362 jjtreeOpenNodeScope(jjtn000);ASTSQLExpression expr;
3363 try {
3364 if (jj_2_9(2147483647)) {
3365 jj_consume_token(163);
3366 SelectStatement(null);
3367 jj_consume_token(165);
3368 jjtree.closeNodeScope(jjtn000, true);
3369 jjtc000 = false;
3370 jjtreeCloseNodeScope(jjtn000);
3371 stat.simpleUpdate = false;
3372 } else {
3373 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3374 case K_CURSYSDATE:
3375 case K_EXISTS:
3376 case K_NEWUID:
3377 case K_NOT:
3378 case K_NULL:
3379 case K_PRIOR:
3380 case K_SYSDATE:
3381 case S_NUMBER:
3382 case S_IDENTIFIER:
3383 case S_BIND:
3384 case S_CHAR_LITERAL:
3385 case S_QUOTED_IDENTIFIER:
3386 case 163:
3387 case 170:
3388 case 171:
3389 expr = SQLExpression();
3390 jjtree.closeNodeScope(jjtn000, true);
3391 jjtc000 = false;
3392 jjtreeCloseNodeScope(jjtn000);
3393 stat.insert( col, expr);
3394 break;
3395 default:
3396 jj_la1[91] = jj_gen;
3397 jj_consume_token(-1);
3398 throw new ParseException();
3399 }
3400 }
3401 } catch (Throwable jjte000) {
3402 if (jjtc000) {
3403 jjtree.clearNodeScope(jjtn000);
3404 jjtc000 = false;
3405 } else {
3406 jjtree.popNode();
3407 }
3408 if (jjte000 instanceof RuntimeException) {
3409 {if (true) throw (RuntimeException)jjte000;}
3410 }
3411 if (jjte000 instanceof ParseException) {
3412 {if (true) throw (ParseException)jjte000;}
3413 }
3414 {if (true) throw (Error)jjte000;}
3415 } finally {
3416 if (jjtc000) {
3417 jjtree.closeNodeScope(jjtn000, true);
3418 jjtreeCloseNodeScope(jjtn000);
3419 }
3420 }
3421 }
3422
3423 static final public void InsertStatement() throws ParseException {
3424 /*@bgen(jjtree) InsertStatement */
3425 ASTInsertStatement jjtn000 = new ASTInsertStatement(JJTINSERTSTATEMENT);
3426 boolean jjtc000 = true;
3427 jjtree.openNodeScope(jjtn000);
3428 jjtreeOpenNodeScope(jjtn000);ASTTableColumn column;
3429 try {
3430 jj_consume_token(K_INSERT);
3431 jj_consume_token(K_INTO);
3432 jjtn000.table = TableReference();
3433 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3434 case 163:
3435 jj_consume_token(163);
3436 column = TableColumn();
3437 jjtn000.addColumn(column);
3438 label_14:
3439 while (true) {
3440 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3441 case 164:
3442 ;
3443 break;
3444 default:
3445 jj_la1[92] = jj_gen;
3446 break label_14;
3447 }
3448 jj_consume_token(164);
3449 column = TableColumn();
3450 jjtn000.addColumn(column);
3451 }
3452 jj_consume_token(165);
3453 break;
3454 default:
3455 jj_la1[93] = jj_gen;
3456 ;
3457 }
3458 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3459 case K_VALUES:
3460 jj_consume_token(K_VALUES);
3461 jj_consume_token(163);
3462 PlSqlExpressionList(jjtn000.values);
3463 jj_consume_token(165);
3464 break;
3465 case K_SELECT:
3466 SelectStatement(null);
3467 jjtn000.simpleInsert = false;
3468 break;
3469 default:
3470 jj_la1[94] = jj_gen;
3471 jj_consume_token(-1);
3472 throw new ParseException();
3473 }
3474 jj_consume_token(161);
3475 } catch (Throwable jjte000) {
3476 if (jjtc000) {
3477 jjtree.clearNodeScope(jjtn000);
3478 jjtc000 = false;
3479 } else {
3480 jjtree.popNode();
3481 }
3482 if (jjte000 instanceof RuntimeException) {
3483 {if (true) throw (RuntimeException)jjte000;}
3484 }
3485 if (jjte000 instanceof ParseException) {
3486 {if (true) throw (ParseException)jjte000;}
3487 }
3488 {if (true) throw (Error)jjte000;}
3489 } finally {
3490 if (jjtc000) {
3491 jjtree.closeNodeScope(jjtn000, true);
3492 jjtreeCloseNodeScope(jjtn000);
3493 }
3494 }
3495 }
3496
3497 static final public void DeleteStatement() throws ParseException {
3498 /*@bgen(jjtree) DeleteStatement */
3499 ASTDeleteStatement jjtn000 = new ASTDeleteStatement(JJTDELETESTATEMENT);
3500 boolean jjtc000 = true;
3501 jjtree.openNodeScope(jjtn000);
3502 jjtreeOpenNodeScope(jjtn000);ASTTableReference table;
3503 Token t = null;
3504 try {
3505 jj_consume_token(K_DELETE);
3506 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3507 case K_FROM:
3508 jj_consume_token(K_FROM);
3509 break;
3510 default:
3511 jj_la1[95] = jj_gen;
3512 ;
3513 }
3514 table = TableReference();
3515 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3516 case S_IDENTIFIER:
3517 t = jj_consume_token(S_IDENTIFIER);
3518 break;
3519 default:
3520 jj_la1[96] = jj_gen;
3521 ;
3522 }
3523 jjtn000.tableName = table.tableName();
3524 if( t == null)
3525 jjtn000.tableId = "";
3526 else
3527 jjtn000.tableId = t.image.trim();
3528 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3529 case K_WHERE:
3530 jj_consume_token(K_WHERE);
3531 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3532 case K_CURSYSDATE:
3533 case K_EXISTS:
3534 case K_NEWUID:
3535 case K_NOT:
3536 case K_NULL:
3537 case K_PRIOR:
3538 case K_SYSDATE:
3539 case S_NUMBER:
3540 case S_IDENTIFIER:
3541 case S_BIND:
3542 case S_CHAR_LITERAL:
3543 case S_QUOTED_IDENTIFIER:
3544 case 163:
3545 case 170:
3546 case 171:
3547 jjtn000.where = SQLExpression();
3548 jjtn000.simpleDelete = true;
3549 break;
3550 case K_CURRENT:
3551 jj_consume_token(K_CURRENT);
3552 jj_consume_token(K_OF);
3553 jj_consume_token(S_IDENTIFIER);
3554 break;
3555 default:
3556 jj_la1[97] = jj_gen;
3557 jj_consume_token(-1);
3558 throw new ParseException();
3559 }
3560 break;
3561 default:
3562 jj_la1[98] = jj_gen;
3563 ;
3564 }
3565 jj_consume_token(161);
3566 } catch (Throwable jjte000) {
3567 if (jjtc000) {
3568 jjtree.clearNodeScope(jjtn000);
3569 jjtc000 = false;
3570 } else {
3571 jjtree.popNode();
3572 }
3573 if (jjte000 instanceof RuntimeException) {
3574 {if (true) throw (RuntimeException)jjte000;}
3575 }
3576 if (jjte000 instanceof ParseException) {
3577 {if (true) throw (ParseException)jjte000;}
3578 }
3579 {if (true) throw (Error)jjte000;}
3580 } finally {
3581 if (jjtc000) {
3582 jjtree.closeNodeScope(jjtn000, true);
3583 jjtreeCloseNodeScope(jjtn000);
3584 }
3585 }
3586 }
3587
3588 // ---------------------------------------------------------------------------
3589 // ---------------------------------------------------------------------------
3590 // ----------- PL-SQL code expression productions start here -----------------
3591 // ---------------------------------------------------------------------------
3592 // ---------------------------------------------------------------------------
3593
3594 // Just a synonym for PlSqlExpressionList for better readability
3595 static final public void Arguments(java.util.Vector params) throws ParseException {
3596 /*@bgen(jjtree) Arguments */
3597 ASTArguments jjtn000 = new ASTArguments(JJTARGUMENTS);
3598 boolean jjtc000 = true;
3599 jjtree.openNodeScope(jjtn000);
3600 jjtreeOpenNodeScope(jjtn000);
3601 try {
3602 PlSqlExpressionList(params);
3603 } catch (Throwable jjte000) {
3604 if (jjtc000) {
3605 jjtree.clearNodeScope(jjtn000);
3606 jjtc000 = false;
3607 } else {
3608 jjtree.popNode();
3609 }
3610 if (jjte000 instanceof RuntimeException) {
3611 {if (true) throw (RuntimeException)jjte000;}
3612 }
3613 if (jjte000 instanceof ParseException) {
3614 {if (true) throw (ParseException)jjte000;}
3615 }
3616 {if (true) throw (Error)jjte000;}
3617 } finally {
3618 if (jjtc000) {
3619 jjtree.closeNodeScope(jjtn000, true);
3620 jjtreeCloseNodeScope(jjtn000);
3621 }
3622 }
3623 }
3624
3625 static final public ASTPlSqlExpression PlSqlExpression() throws ParseException {
3626 /*@bgen(jjtree) PlSqlExpression */
3627 ASTPlSqlExpression jjtn000 = new ASTPlSqlExpression(JJTPLSQLEXPRESSION);
3628 boolean jjtc000 = true;
3629 jjtree.openNodeScope(jjtn000);
3630 jjtreeOpenNodeScope(jjtn000);ASTPlSqlAndExpression expr;
3631 try {
3632 expr = PlSqlAndExpression();
3633 jjtn000.ors.addElement( expr);
3634 label_15:
3635 while (true) {
3636 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3637 case K_OR:
3638 ;
3639 break;
3640 default:
3641 jj_la1[99] = jj_gen;
3642 break label_15;
3643 }
3644 jj_consume_token(K_OR);
3645 expr = PlSqlAndExpression();
3646 jjtn000.ors.addElement( expr);
3647 }
3648 jjtree.closeNodeScope(jjtn000, true);
3649 jjtc000 = false;
3650 jjtreeCloseNodeScope(jjtn000);
3651 {if (true) return jjtn000;}
3652 } catch (Throwable jjte000) {
3653 if (jjtc000) {
3654 jjtree.clearNodeScope(jjtn000);
3655 jjtc000 = false;
3656 } else {
3657 jjtree.popNode();
3658 }
3659 if (jjte000 instanceof RuntimeException) {
3660 {if (true) throw (RuntimeException)jjte000;}
3661 }
3662 if (jjte000 instanceof ParseException) {
3663 {if (true) throw (ParseException)jjte000;}
3664 }
3665 {if (true) throw (Error)jjte000;}
3666 } finally {
3667 if (jjtc000) {
3668 jjtree.closeNodeScope(jjtn000, true);
3669 jjtreeCloseNodeScope(jjtn000);
3670 }
3671 }
3672 throw new Error("Missing return statement in function");
3673 }
3674
3675 static final public ASTPlSqlAndExpression PlSqlAndExpression() throws ParseException {
3676 /*@bgen(jjtree) PlSqlAndExpression */
3677 ASTPlSqlAndExpression jjtn000 = new ASTPlSqlAndExpression(JJTPLSQLANDEXPRESSION);
3678 boolean jjtc000 = true;
3679 jjtree.openNodeScope(jjtn000);
3680 jjtreeOpenNodeScope(jjtn000);ASTPlSqlUnaryLogicalExpression expr;
3681 try {
3682 expr = PlSqlUnaryLogicalExpression();
3683 jjtn000.ands.addElement( expr);
3684 label_16:
3685 while (true) {
3686 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3687 case K_AND:
3688 ;
3689 break;
3690 default:
3691 jj_la1[100] = jj_gen;
3692 break label_16;
3693 }
3694 jj_consume_token(K_AND);
3695 expr = PlSqlUnaryLogicalExpression();
3696 jjtn000.ands.addElement( expr);
3697 }
3698 jjtree.closeNodeScope(jjtn000, true);
3699 jjtc000 = false;
3700 jjtreeCloseNodeScope(jjtn000);
3701 {if (true) return jjtn000;}
3702 } catch (Throwable jjte000) {
3703 if (jjtc000) {
3704 jjtree.clearNodeScope(jjtn000);
3705 jjtc000 = false;
3706 } else {
3707 jjtree.popNode();
3708 }
3709 if (jjte000 instanceof RuntimeException) {
3710 {if (true) throw (RuntimeException)jjte000;}
3711 }
3712 if (jjte000 instanceof ParseException) {
3713 {if (true) throw (ParseException)jjte000;}
3714 }
3715 {if (true) throw (Error)jjte000;}
3716 } finally {
3717 if (jjtc000) {
3718 jjtree.closeNodeScope(jjtn000, true);
3719 jjtreeCloseNodeScope(jjtn000);
3720 }
3721 }
3722 throw new Error("Missing return statement in function");
3723 }
3724
3725 static final public ASTPlSqlUnaryLogicalExpression PlSqlUnaryLogicalExpression() throws ParseException {
3726 /*@bgen(jjtree) PlSqlUnaryLogicalExpression */
3727 ASTPlSqlUnaryLogicalExpression jjtn000 = new ASTPlSqlUnaryLogicalExpression(JJTPLSQLUNARYLOGICALEXPRESSION);
3728 boolean jjtc000 = true;
3729 jjtree.openNodeScope(jjtn000);
3730 jjtreeOpenNodeScope(jjtn000);
3731 try {
3732 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3733 case K_NOT:
3734 jj_consume_token(K_NOT);
3735 jjtn000.not = true;
3736 break;
3737 default:
3738 jj_la1[101] = jj_gen;
3739 ;
3740 }
3741 jjtn000.expr = PlSqlRelationalExpression();
3742 jjtree.closeNodeScope(jjtn000, true);
3743 jjtc000 = false;
3744 jjtreeCloseNodeScope(jjtn000);
3745 {if (true) return jjtn000;}
3746 } catch (Throwable jjte000) {
3747 if (jjtc000) {
3748 jjtree.clearNodeScope(jjtn000);
3749 jjtc000 = false;
3750 } else {
3751 jjtree.popNode();
3752 }
3753 if (jjte000 instanceof RuntimeException) {
3754 {if (true) throw (RuntimeException)jjte000;}
3755 }
3756 if (jjte000 instanceof ParseException) {
3757 {if (true) throw (ParseException)jjte000;}
3758 }
3759 {if (true) throw (Error)jjte000;}
3760 } finally {
3761 if (jjtc000) {
3762 jjtree.closeNodeScope(jjtn000, true);
3763 jjtreeCloseNodeScope(jjtn000);
3764 }
3765 }
3766 throw new Error("Missing return statement in function");
3767 }
3768
3769 static final public ASTPlSqlRelationalExpression PlSqlRelationalExpression() throws ParseException {
3770 /*@bgen(jjtree) PlSqlRelationalExpression */
3771 ASTPlSqlRelationalExpression jjtn000 = new ASTPlSqlRelationalExpression(JJTPLSQLRELATIONALEXPRESSION);
3772 boolean jjtc000 = true;
3773 jjtree.openNodeScope(jjtn000);
3774 jjtreeOpenNodeScope(jjtn000);
3775 try {
3776 jjtn000.first = PlSqlSimpleExpression();
3777 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3778 case 153:
3779 case 154:
3780 case 155:
3781 case 156:
3782 case 157:
3783 case 158:
3784 case 159:
3785 jjtn000.v1 = Relop();
3786 jjtn000.v2 = PlSqlSimpleExpression();
3787 jjtn000.type = 1;
3788 break;
3789 default:
3790 jj_la1[102] = jj_gen;
3791 ;
3792 }
3793 jjtree.closeNodeScope(jjtn000, true);
3794 jjtc000 = false;
3795 jjtreeCloseNodeScope(jjtn000);
3796 {if (true) return jjtn000;}
3797 } catch (Throwable jjte000) {
3798 if (jjtc000) {
3799 jjtree.clearNodeScope(jjtn000);
3800 jjtc000 = false;
3801 } else {
3802 jjtree.popNode();
3803 }
3804 if (jjte000 instanceof RuntimeException) {
3805 {if (true) throw (RuntimeException)jjte000;}
3806 }
3807 if (jjte000 instanceof ParseException) {
3808 {if (true) throw (ParseException)jjte000;}
3809 }
3810 {if (true) throw (Error)jjte000;}
3811 } finally {
3812 if (jjtc000) {
3813 jjtree.closeNodeScope(jjtn000, true);
3814 jjtreeCloseNodeScope(jjtn000);
3815 }
3816 }
3817 throw new Error("Missing return statement in function");
3818 }
3819
3820 static final public void PlSqlExpressionList(java.util.Vector params) throws ParseException {
3821 /*@bgen(jjtree) PlSqlExpressionList */
3822 ASTPlSqlExpressionList jjtn000 = new ASTPlSqlExpressionList(JJTPLSQLEXPRESSIONLIST);
3823 boolean jjtc000 = true;
3824 jjtree.openNodeScope(jjtn000);
3825 jjtreeOpenNodeScope(jjtn000);ASTPlSqlExpression expr;
3826 try {
3827 expr = PlSqlExpression();
3828 if( params != null) params.addElement( expr);
3829 label_17:
3830 while (true) {
3831 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3832 case 164:
3833 ;
3834 break;
3835 default:
3836 jj_la1[103] = jj_gen;
3837 break label_17;
3838 }
3839 jj_consume_token(164);
3840 expr = PlSqlExpression();
3841 if( params != null) params.addElement( expr);
3842 }
3843 } catch (Throwable jjte000) {
3844 if (jjtc000) {
3845 jjtree.clearNodeScope(jjtn000);
3846 jjtc000 = false;
3847 } else {
3848 jjtree.popNode();
3849 }
3850 if (jjte000 instanceof RuntimeException) {
3851 {if (true) throw (RuntimeException)jjte000;}
3852 }
3853 if (jjte000 instanceof ParseException) {
3854 {if (true) throw (ParseException)jjte000;}
3855 }
3856 {if (true) throw (Error)jjte000;}
3857 } finally {
3858 if (jjtc000) {
3859 jjtree.closeNodeScope(jjtn000, true);
3860 jjtreeCloseNodeScope(jjtn000);
3861 }
3862 }
3863 }
3864
3865 static final public void PlSqlInClause() throws ParseException {
3866 /*@bgen(jjtree) PlSqlInClause */
3867 ASTPlSqlInClause jjtn000 = new ASTPlSqlInClause(JJTPLSQLINCLAUSE);
3868 boolean jjtc000 = true;
3869 jjtree.openNodeScope(jjtn000);
3870 jjtreeOpenNodeScope(jjtn000);
3871 try {
3872 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3873 case K_NOT:
3874 jj_consume_token(K_NOT);
3875 break;
3876 default:
3877 jj_la1[104] = jj_gen;
3878 ;
3879 }
3880 jj_consume_token(K_IN);
3881 jj_consume_token(163);
3882 PlSqlExpressionList(null);
3883 jj_consume_token(165);
3884 } catch (Throwable jjte000) {
3885 if (jjtc000) {
3886 jjtree.clearNodeScope(jjtn000);
3887 jjtc000 = false;
3888 } else {
3889 jjtree.popNode();
3890 }
3891 if (jjte000 instanceof RuntimeException) {
3892 {if (true) throw (RuntimeException)jjte000;}
3893 }
3894 if (jjte000 instanceof ParseException) {
3895 {if (true) throw (ParseException)jjte000;}
3896 }
3897 {if (true) throw (Error)jjte000;}
3898 } finally {
3899 if (jjtc000) {
3900 jjtree.closeNodeScope(jjtn000, true);
3901 jjtreeCloseNodeScope(jjtn000);
3902 }
3903 }
3904 }
3905
3906 static final public void PlSqlBetweenClause() throws ParseException {
3907 /*@bgen(jjtree) PlSqlBetweenClause */
3908 ASTPlSqlBetweenClause jjtn000 = new ASTPlSqlBetweenClause(JJTPLSQLBETWEENCLAUSE);
3909 boolean jjtc000 = true;
3910 jjtree.openNodeScope(jjtn000);
3911 jjtreeOpenNodeScope(jjtn000);
3912 try {
3913 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3914 case K_NOT:
3915 jj_consume_token(K_NOT);
3916 break;
3917 default:
3918 jj_la1[105] = jj_gen;
3919 ;
3920 }
3921 jj_consume_token(K_BETWEEN);
3922 PlSqlSimpleExpression();
3923 jj_consume_token(K_AND);
3924 PlSqlSimpleExpression();
3925 } catch (Throwable jjte000) {
3926 if (jjtc000) {
3927 jjtree.clearNodeScope(jjtn000);
3928 jjtc000 = false;
3929 } else {
3930 jjtree.popNode();
3931 }
3932 if (jjte000 instanceof RuntimeException) {
3933 {if (true) throw (RuntimeException)jjte000;}
3934 }
3935 if (jjte000 instanceof ParseException) {
3936 {if (true) throw (ParseException)jjte000;}
3937 }
3938 {if (true) throw (Error)jjte000;}
3939 } finally {
3940 if (jjtc000) {
3941 jjtree.closeNodeScope(jjtn000, true);
3942 jjtreeCloseNodeScope(jjtn000);
3943 }
3944 }
3945 }
3946
3947 static final public void PlSqlLikeClause() throws ParseException {
3948 /*@bgen(jjtree) PlSqlLikeClause */
3949 ASTPlSqlLikeClause jjtn000 = new ASTPlSqlLikeClause(JJTPLSQLLIKECLAUSE);
3950 boolean jjtc000 = true;
3951 jjtree.openNodeScope(jjtn000);
3952 jjtreeOpenNodeScope(jjtn000);
3953 try {
3954 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3955 case K_NOT:
3956 jj_consume_token(K_NOT);
3957 break;
3958 default:
3959 jj_la1[106] = jj_gen;
3960 ;
3961 }
3962 jj_consume_token(K_LIKE);
3963 PlSqlSimpleExpression();
3964 } catch (Throwable jjte000) {
3965 if (jjtc000) {
3966 jjtree.clearNodeScope(jjtn000);
3967 jjtc000 = false;
3968 } else {
3969 jjtree.popNode();
3970 }
3971 if (jjte000 instanceof RuntimeException) {
3972 {if (true) throw (RuntimeException)jjte000;}
3973 }
3974 if (jjte000 instanceof ParseException) {
3975 {if (true) throw (ParseException)jjte000;}
3976 }
3977 {if (true) throw (Error)jjte000;}
3978 } finally {
3979 if (jjtc000) {
3980 jjtree.closeNodeScope(jjtn000, true);
3981 jjtreeCloseNodeScope(jjtn000);
3982 }
3983 }
3984 }
3985
3986 static final public void IsNullClause() throws ParseException {
3987 /*@bgen(jjtree) IsNullClause */
3988 ASTIsNullClause jjtn000 = new ASTIsNullClause(JJTISNULLCLAUSE);
3989 boolean jjtc000 = true;
3990 jjtree.openNodeScope(jjtn000);
3991 jjtreeOpenNodeScope(jjtn000);
3992 try {
3993 jj_consume_token(K_IS);
3994 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3995 case K_NOT:
3996 jj_consume_token(K_NOT);
3997 break;
3998 default:
3999 jj_la1[107] = jj_gen;
4000 ;
4001 }
4002 jj_consume_token(K_NULL);
4003 } finally {
4004 if (jjtc000) {
4005 jjtree.closeNodeScope(jjtn000, true);
4006 jjtreeCloseNodeScope(jjtn000);
4007 }
4008 }
4009 }
4010
4011 static final public ASTPlSqlSimpleExpression PlSqlSimpleExpression() throws ParseException {
4012 /*@bgen(jjtree) PlSqlSimpleExpression */
4013 ASTPlSqlSimpleExpression jjtn000 = new ASTPlSqlSimpleExpression(JJTPLSQLSIMPLEEXPRESSION);
4014 boolean jjtc000 = true;
4015 jjtree.openNodeScope(jjtn000);
4016 jjtreeOpenNodeScope(jjtn000);ASTPlSqlMultiplicativeExpression expr;
4017 byte opType;
4018 try {
4019 expr = PlSqlMultiplicativeExpression();
4020 jjtn000.first = expr;
4021 label_18:
4022 while (true) {
4023 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4024 case 170:
4025 case 171:
4026 case 172:
4027 ;
4028 break;
4029 default:
4030 jj_la1[108] = jj_gen;
4031 break label_18;
4032 }
4033 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4034 case 170:
4035 jj_consume_token(170);
4036 opType = jjtn000.OP_PLUS;
4037 break;
4038 case 171:
4039 jj_consume_token(171);
4040 opType = jjtn000.OP_MINUS;
4041 break;
4042 case 172:
4043 jj_consume_token(172);
4044 opType = jjtn000.OP_OR; System.out.println("Here");
4045 break;
4046 default:
4047 jj_la1[109] = jj_gen;
4048 jj_consume_token(-1);
4049 throw new ParseException();
4050 }
4051 expr = PlSqlMultiplicativeExpression();
4052 jjtn000.insert( opType, expr);
4053 }
4054 jjtree.closeNodeScope(jjtn000, true);
4055 jjtc000 = false;
4056 jjtreeCloseNodeScope(jjtn000);
4057 {if (true) return jjtn000;}
4058 } catch (Throwable jjte000) {
4059 if (jjtc000) {
4060 jjtree.clearNodeScope(jjtn000);
4061 jjtc000 = false;
4062 } else {
4063 jjtree.popNode();
4064 }
4065 if (jjte000 instanceof RuntimeException) {
4066 {if (true) throw (RuntimeException)jjte000;}
4067 }
4068 if (jjte000 instanceof ParseException) {
4069 {if (true) throw (ParseException)jjte000;}
4070 }
4071 {if (true) throw (Error)jjte000;}
4072 } finally {
4073 if (jjtc000) {
4074 jjtree.closeNodeScope(jjtn000, true);
4075 jjtreeCloseNodeScope(jjtn000);
4076 }
4077 }
4078 throw new Error("Missing return statement in function");
4079 }
4080
4081 static final public ASTPlSqlMultiplicativeExpression PlSqlMultiplicativeExpression() throws ParseException {
4082 /*@bgen(jjtree) PlSqlMultiplicativeExpression */
4083 ASTPlSqlMultiplicativeExpression jjtn000 = new ASTPlSqlMultiplicativeExpression(JJTPLSQLMULTIPLICATIVEEXPRESSION);
4084 boolean jjtc000 = true;
4085 jjtree.openNodeScope(jjtn000);
4086 jjtreeOpenNodeScope(jjtn000);ASTPlSqlExpotentExpression expr;
4087 byte opType;
4088 try {
4089 expr = PlSqlExpotentExpression();
4090 jjtn000.first = expr;
4091 label_19:
4092 while (true) {
4093 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4094 case 173:
4095 case 174:
4096 ;
4097 break;
4098 default:
4099 jj_la1[110] = jj_gen;
4100 break label_19;
4101 }
4102 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4103 case 173:
4104 jj_consume_token(173);
4105 opType = jjtn000.OP_MULTI;
4106 break;
4107 case 174:
4108 jj_consume_token(174);
4109 opType = jjtn000.OP_DIVI;
4110 break;
4111 default:
4112 jj_la1[111] = jj_gen;
4113 jj_consume_token(-1);
4114 throw new ParseException();
4115 }
4116 expr = PlSqlExpotentExpression();
4117 jjtn000.insert( opType, expr);
4118 }
4119 jjtree.closeNodeScope(jjtn000, true);
4120 jjtc000 = false;
4121 jjtreeCloseNodeScope(jjtn000);
4122 {if (true) return jjtn000;}
4123 } catch (Throwable jjte000) {
4124 if (jjtc000) {
4125 jjtree.clearNodeScope(jjtn000);
4126 jjtc000 = false;
4127 } else {
4128 jjtree.popNode();
4129 }
4130 if (jjte000 instanceof RuntimeException) {
4131 {if (true) throw (RuntimeException)jjte000;}
4132 }
4133 if (jjte000 instanceof ParseException) {
4134 {if (true) throw (ParseException)jjte000;}
4135 }
4136 {if (true) throw (Error)jjte000;}
4137 } finally {
4138 if (jjtc000) {
4139 jjtree.closeNodeScope(jjtn000, true);
4140 jjtreeCloseNodeScope(jjtn000);
4141 }
4142 }
4143 throw new Error("Missing return statement in function");
4144 }
4145
4146 static final public ASTPlSqlExpotentExpression PlSqlExpotentExpression() throws ParseException {
4147 /*@bgen(jjtree) PlSqlExpotentExpression */
4148 ASTPlSqlExpotentExpression jjtn000 = new ASTPlSqlExpotentExpression(JJTPLSQLEXPOTENTEXPRESSION);
4149 boolean jjtc000 = true;
4150 jjtree.openNodeScope(jjtn000);
4151 jjtreeOpenNodeScope(jjtn000);ASTPlSqlUnaryExpression expr;
4152 try {
4153 expr = PlSqlUnaryExpression();
4154 jjtn000.els.addElement( expr);
4155 label_20:
4156 while (true) {
4157 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4158 case 175:
4159 ;
4160 break;
4161 default:
4162 jj_la1[112] = jj_gen;
4163 break label_20;
4164 }
4165 jj_consume_token(175);
4166 expr = PlSqlUnaryExpression();
4167 jjtn000.els.addElement( expr);
4168 }
4169 jjtree.closeNodeScope(jjtn000, true);
4170 jjtc000 = false;
4171 jjtreeCloseNodeScope(jjtn000);
4172 {if (true) return jjtn000;}
4173 } catch (Throwable jjte000) {
4174 if (jjtc000) {
4175 jjtree.clearNodeScope(jjtn000);
4176 jjtc000 = false;
4177 } else {
4178 jjtree.popNode();
4179 }
4180 if (jjte000 instanceof RuntimeException) {
4181 {if (true) throw (RuntimeException)jjte000;}
4182 }
4183 if (jjte000 instanceof ParseException) {
4184 {if (true) throw (ParseException)jjte000;}
4185 }
4186 {if (true) throw (Error)jjte000;}
4187 } finally {
4188 if (jjtc000) {
4189 jjtree.closeNodeScope(jjtn000, true);
4190 jjtreeCloseNodeScope(jjtn000);
4191 }
4192 }
4193 throw new Error("Missing return statement in function");
4194 }
4195
4196 static final public ASTPlSqlUnaryExpression PlSqlUnaryExpression() throws ParseException {
4197 /*@bgen(jjtree) PlSqlUnaryExpression */
4198 ASTPlSqlUnaryExpression jjtn000 = new ASTPlSqlUnaryExpression(JJTPLSQLUNARYEXPRESSION);
4199 boolean jjtc000 = true;
4200 jjtree.openNodeScope(jjtn000);
4201 jjtreeOpenNodeScope(jjtn000);
4202 try {
4203 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4204 case 170:
4205 case 171:
4206 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4207 case 170:
4208 jj_consume_token(170);
4209 jjtn000.sign = 1;
4210 break;
4211 case 171:
4212 jj_consume_token(171);
4213 jjtn000.sign = 2;
4214 break;
4215 default:
4216 jj_la1[113] = jj_gen;
4217 jj_consume_token(-1);
4218 throw new ParseException();
4219 }
4220 break;
4221 default:
4222 jj_la1[114] = jj_gen;
4223 ;
4224 }
4225 jjtn000.expr = PlSqlPrimaryExpression();
4226 jjtree.closeNodeScope(jjtn000, true);
4227 jjtc000 = false;
4228 jjtreeCloseNodeScope(jjtn000);
4229 {if (true) return jjtn000;}
4230 } catch (Throwable jjte000) {
4231 if (jjtc000) {
4232 jjtree.clearNodeScope(jjtn000);
4233 jjtc000 = false;
4234 } else {
4235 jjtree.popNode();
4236 }
4237 if (jjte000 instanceof RuntimeException) {
4238 {if (true) throw (RuntimeException)jjte000;}
4239 }
4240 if (jjte000 instanceof ParseException) {
4241 {if (true) throw (ParseException)jjte000;}
4242 }
4243 {if (true) throw (Error)jjte000;}
4244 } finally {
4245 if (jjtc000) {
4246 jjtree.closeNodeScope(jjtn000, true);
4247 jjtreeCloseNodeScope(jjtn000);
4248 }
4249 }
4250 throw new Error("Missing return statement in function");
4251 }
4252
4253 static final public ASTPlSqlPrimaryExpression PlSqlPrimaryExpression() throws ParseException {
4254 /*@bgen(jjtree) PlSqlPrimaryExpression */
4255 ASTPlSqlPrimaryExpression jjtn000 = new ASTPlSqlPrimaryExpression(JJTPLSQLPRIMARYEXPRESSION);
4256 boolean jjtc000 = true;
4257 jjtree.openNodeScope(jjtn000);
4258 jjtreeOpenNodeScope(jjtn000);Token t;
4259 try {
4260 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4261 case K_NULL:
4262 jj_consume_token(K_NULL);
4263 jjtree.closeNodeScope(jjtn000, true);
4264 jjtc000 = false;
4265 jjtreeCloseNodeScope(jjtn000);
4266 jjtn000.type = jjtn000.EXPR_NULL;
4267 {if (true) return jjtn000;}
4268 break;
4269 case S_IDENTIFIER:
4270 t = jj_consume_token(S_IDENTIFIER);
4271 jjtn000.v1 = t.image;
4272 jjtree.closeNodeScope(jjtn000, true);
4273 jjtc000 = false;
4274 jjtreeCloseNodeScope(jjtn000);
4275 jjtn000.type = jjtn000.EXPR_VARIABLE;
4276 {if (true) return jjtn000;}
4277 break;
4278 case K_SYSDATE:
4279 jj_consume_token(K_SYSDATE);
4280 jjtree.closeNodeScope(jjtn000, true);
4281 jjtc000 = false;
4282 jjtreeCloseNodeScope(jjtn000);
4283 jjtn000.type = jjtn000.EXPR_SYSDATE;
4284 {if (true) return jjtn000;}
4285 break;
4286 case K_CURSYSDATE:
4287 jj_consume_token(K_CURSYSDATE);
4288 jjtree.closeNodeScope(jjtn000, true);
4289 jjtc000 = false;
4290 jjtreeCloseNodeScope(jjtn000);
4291 jjtn000.type = jjtn000.EXPR_CURSYSDATE;
4292 jjtn000.v1 = new java.util.Date();
4293 {if (true) return jjtn000;}
4294 break;
4295 case K_NEWUID:
4296 jj_consume_token(K_NEWUID);
4297 jjtree.closeNodeScope(jjtn000, true);
4298 jjtc000 = false;
4299 jjtreeCloseNodeScope(jjtn000);
4300 jjtn000.type = jjtn000.EXPR_NEWUID;
4301 jjtn000.v1 = MobisnapSQL.uids.getNewUID();
4302 {if (true) return jjtn000;}
4303 break;
4304 case S_NUMBER:
4305 t = jj_consume_token(S_NUMBER);
4306 jjtree.closeNodeScope(jjtn000, true);
4307 jjtc000 = false;
4308 jjtreeCloseNodeScope(jjtn000);
4309 jjtn000.v1 = t.image;
4310 jjtn000.type = jjtn000.EXPR_SQLNUMBER;
4311 {if (true) return jjtn000;}
4312 break;
4313 case S_CHAR_LITERAL:
4314 t = jj_consume_token(S_CHAR_LITERAL);
4315 jjtree.closeNodeScope(jjtn000, true);
4316 jjtc000 = false;
4317 jjtreeCloseNodeScope(jjtn000);
4318 jjtn000.v1 = t.image.substring( 1, t.image.length() - 1);
4319 jjtn000.type = jjtn000.EXPR_SQLCHARLITERAL;
4320 {if (true) return jjtn000;}
4321 break;
4322 case 163:
4323 jj_consume_token(163);
4324 jjtn000.v1 = PlSqlExpression();
4325 jj_consume_token(165);
4326 jjtree.closeNodeScope(jjtn000, true);
4327 jjtc000 = false;
4328 jjtreeCloseNodeScope(jjtn000);
4329 jjtn000.type = jjtn000.EXPR_SQLEXPR;
4330 {if (true) return jjtn000;}
4331 break;
4332 default:
4333 jj_la1[115] = jj_gen;
4334 jj_consume_token(-1);
4335 throw new ParseException();
4336 }
4337 } catch (Throwable jjte000) {
4338 if (jjtc000) {
4339 jjtree.clearNodeScope(jjtn000);
4340 jjtc000 = false;
4341 } else {
4342 jjtree.popNode();
4343 }
4344 if (jjte000 instanceof RuntimeException) {
4345 {if (true) throw (RuntimeException)jjte000;}
4346 }
4347 if (jjte000 instanceof ParseException) {
4348 {if (true) throw (ParseException)jjte000;}
4349 }
4350 {if (true) throw (Error)jjte000;}
4351 } finally {
4352 if (jjtc000) {
4353 jjtree.closeNodeScope(jjtn000, true);
4354 jjtreeCloseNodeScope(jjtn000);
4355 }
4356 }
4357 throw new Error("Missing return statement in function");
4358 }
4359
4360 // ---------------------------------------------------------------------------
4361 // ---------------------------------------------------------------------------
4362 // ----------- SQL productions start here -----------------
4363 // ---------------------------------------------------------------------------
4364 // ---------------------------------------------------------------------------
4365 static final public ASTSQLStatement SQLStatement() throws ParseException {
4366 /*@bgen(jjtree) SQLStatement */
4367 ASTSQLStatement jjtn000 = new ASTSQLStatement(JJTSQLSTATEMENT);
4368 boolean jjtc000 = true;
4369 jjtree.openNodeScope(jjtn000);
4370 jjtreeOpenNodeScope(jjtn000);
4371 try {
4372 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4373 case K_COMMIT:
4374 CommitStatement();
4375 break;
4376 case K_DELETE:
4377 DeleteStatement();
4378 break;
4379 case K_INSERT:
4380 InsertStatement();
4381 break;
4382 case K_ROLLBACK:
4383 RollbackStatement();
4384 break;
4385 case K_SELECT:
4386 QueryStatement();
4387 break;
4388 case K_UPDATE:
4389 UpdateStatement();
4390 break;
4391 default:
4392 jj_la1[116] = jj_gen;
4393 jj_consume_token(-1);
4394 throw new ParseException();
4395 }
4396 jjtree.closeNodeScope(jjtn000, true);
4397 jjtc000 = false;
4398 jjtreeCloseNodeScope(jjtn000);
4399 {if (true) return jjtn000;}
4400 } catch (Throwable jjte000) {
4401 if (jjtc000) {
4402 jjtree.clearNodeScope(jjtn000);
4403 jjtc000 = false;
4404 } else {
4405 jjtree.popNode();
4406 }
4407 if (jjte000 instanceof RuntimeException) {
4408 {if (true) throw (RuntimeException)jjte000;}
4409 }
4410 if (jjte000 instanceof ParseException) {
4411 {if (true) throw (ParseException)jjte000;}
4412 }
4413 {if (true) throw (Error)jjte000;}
4414 } finally {
4415 if (jjtc000) {
4416 jjtree.closeNodeScope(jjtn000, true);
4417 jjtreeCloseNodeScope(jjtn000);
4418 }
4419 }
4420 throw new Error("Missing return statement in function");
4421 }
4422
4423 static final public ASTQueryStatement QueryStatement() throws ParseException {
4424 /*@bgen(jjtree) QueryStatement */
4425 ASTQueryStatement jjtn000 = new ASTQueryStatement(JJTQUERYSTATEMENT);
4426 boolean jjtc000 = true;
4427 jjtree.openNodeScope(jjtn000);
4428 jjtreeOpenNodeScope(jjtn000);
4429 try {
4430 SelectStatement(jjtn000);
4431 jj_consume_token(161);
4432 jjtree.closeNodeScope(jjtn000, true);
4433 jjtc000 = false;
4434 jjtreeCloseNodeScope(jjtn000);
4435 {if (true) return jjtn000;}
4436 } catch (Throwable jjte000) {
4437 if (jjtc000) {
4438 jjtree.clearNodeScope(jjtn000);
4439 jjtc000 = false;
4440 } else {
4441 jjtree.popNode();
4442 }
4443 if (jjte000 instanceof RuntimeException) {
4444 {if (true) throw (RuntimeException)jjte000;}
4445 }
4446 if (jjte000 instanceof ParseException) {
4447 {if (true) throw (ParseException)jjte000;}
4448 }
4449 {if (true) throw (Error)jjte000;}
4450 } finally {
4451 if (jjtc000) {
4452 jjtree.closeNodeScope(jjtn000, true);
4453 jjtreeCloseNodeScope(jjtn000);
4454 }
4455 }
4456 throw new Error("Missing return statement in function");
4457 }
4458
4459 static final public void SelectStatement(ASTQueryStatement query) throws ParseException {
4460 /*@bgen(jjtree) SelectStatement */
4461 ASTSelectStatement jjtn000 = new ASTSelectStatement(JJTSELECTSTATEMENT);
4462 boolean jjtc000 = true;
4463 jjtree.openNodeScope(jjtn000);
4464 jjtreeOpenNodeScope(jjtn000);
4465 try {
4466 SelectWithoutOrder(query);
4467 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4468 case K_ORDER:
4469 OrderByClause();
4470 if( query != null) query.orderBy = true;
4471 break;
4472 default:
4473 jj_la1[117] = jj_gen;
4474 ;
4475 }
4476 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4477 case K_FOR:
4478 ForUpdateClause();
4479 if( query != null) query.forUpdate = true;
4480 break;
4481 default:
4482 jj_la1[118] = jj_gen;
4483 ;
4484 }
4485 } catch (Throwable jjte000) {
4486 if (jjtc000) {
4487 jjtree.clearNodeScope(jjtn000);
4488 jjtc000 = false;
4489 } else {
4490 jjtree.popNode();
4491 }
4492 if (jjte000 instanceof RuntimeException) {
4493 {if (true) throw (RuntimeException)jjte000;}
4494 }
4495 if (jjte000 instanceof ParseException) {
4496 {if (true) throw (ParseException)jjte000;}
4497 }
4498 {if (true) throw (Error)jjte000;}
4499 } finally {
4500 if (jjtc000) {
4501 jjtree.closeNodeScope(jjtn000, true);
4502 jjtreeCloseNodeScope(jjtn000);
4503 }
4504 }
4505 }
4506
4507 static final public void SelectWithoutOrder(ASTQueryStatement query) throws ParseException {
4508 /*@bgen(jjtree) SelectWithoutOrder */
4509 ASTSelectWithoutOrder jjtn000 = new ASTSelectWithoutOrder(JJTSELECTWITHOUTORDER);
4510 boolean jjtc000 = true;
4511 jjtree.openNodeScope(jjtn000);
4512 jjtreeOpenNodeScope(jjtn000);java.util.Vector aux;
4513 java.util.Vector aux2;
4514 ASTSQLExpression expr;
4515 try {
4516 jj_consume_token(K_SELECT);
4517 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4518 case K_ALL:
4519 case K_DISTINCT:
4520 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4521 case K_ALL:
4522 jj_consume_token(K_ALL);
4523 break;
4524 case K_DISTINCT:
4525 jj_consume_token(K_DISTINCT);
4526 break;
4527 default:
4528 jj_la1[119] = jj_gen;
4529 jj_consume_token(-1);
4530 throw new ParseException();
4531 }
4532 break;
4533 default:
4534 jj_la1[120] = jj_gen;
4535 ;
4536 }
4537 SelectList(query);
4538 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4539 case K_INTO:
4540 if( query != null) aux = query.into; else aux = null;
4541 jjtn000.intoNode = IntoClause(aux);
4542 break;
4543 default:
4544 jj_la1[121] = jj_gen;
4545 ;
4546 }
4547 if( query != null) aux = query.from; else aux = null;
4548 if( query != null) aux2 = query.fromid; else aux2 = null;
4549 FromClause(aux, aux2);
4550 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4551 case K_WHERE:
4552 expr = WhereClause();
4553 if( query != null) query.where = expr;
4554 break;
4555 default:
4556 jj_la1[122] = jj_gen;
4557 ;
4558 }
4559 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4560 case K_CONNECT:
4561 case K_START:
4562 ConnectClause();
4563 if( query != null) query.connect = true;
4564 break;
4565 default:
4566 jj_la1[123] = jj_gen;
4567 ;
4568 }
4569 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4570 case K_GROUP:
4571 GroupByClause();
4572 if( query != null) query.groupBy = true;
4573 break;
4574 default:
4575 jj_la1[124] = jj_gen;
4576 ;
4577 }
4578 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4579 case K_INTERSECT:
4580 case K_MINUS:
4581 case K_UNION:
4582 SetClause();
4583 if( query != null) query.setClause = true;
4584 break;
4585 default:
4586 jj_la1[125] = jj_gen;
4587 ;
4588 }
4589 } catch (Throwable jjte000) {
4590 if (jjtc000) {
4591 jjtree.clearNodeScope(jjtn000);
4592 jjtc000 = false;
4593 } else {
4594 jjtree.popNode();
4595 }
4596 if (jjte000 instanceof RuntimeException) {
4597 {if (true) throw (RuntimeException)jjte000;}
4598 }
4599 if (jjte000 instanceof ParseException) {
4600 {if (true) throw (ParseException)jjte000;}
4601 }
4602 {if (true) throw (Error)jjte000;}
4603 } finally {
4604 if (jjtc000) {
4605 jjtree.closeNodeScope(jjtn000, true);
4606 jjtreeCloseNodeScope(jjtn000);
4607 }
4608 }
4609 }
4610
4611 static final public ASTMonitorQueryStatement MonitorQueryStatement() throws ParseException {
4612 /*@bgen(jjtree) MonitorQueryStatement */
4613 ASTMonitorQueryStatement jjtn000 = new ASTMonitorQueryStatement(JJTMONITORQUERYSTATEMENT);
4614 boolean jjtc000 = true;
4615 jjtree.openNodeScope(jjtn000);
4616 jjtreeOpenNodeScope(jjtn000);java.util.Vector aux;
4617 ASTSQLExpression expr;
4618 try {
4619 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4620 case K_ALL:
4621 case K_DISTINCT:
4622 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4623 case K_ALL:
4624 jj_consume_token(K_ALL);
4625 break;
4626 case K_DISTINCT:
4627 jj_consume_token(K_DISTINCT);
4628 break;
4629 default:
4630 jj_la1[126] = jj_gen;
4631 jj_consume_token(-1);
4632 throw new ParseException();
4633 }
4634 break;
4635 default:
4636 jj_la1[127] = jj_gen;
4637 ;
4638 }
4639 SelectList(jjtn000);
4640 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4641 case K_INTO:
4642 if( jjtn000 != null) aux = jjtn000.into; else aux = null;
4643 jjtn000.intoNode = IntoClause(aux);
4644 break;
4645 default:
4646 jj_la1[128] = jj_gen;
4647 ;
4648 }
4649 if( jjtn000 != null) aux = jjtn000.from; else aux = null;
4650 FromClause(aux, null);
4651 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4652 case K_WHERE:
4653 expr = WhereClause();
4654 if( jjtn000 != null) jjtn000.where = expr;
4655 break;
4656 default:
4657 jj_la1[129] = jj_gen;
4658 ;
4659 }
4660 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4661 case K_CONNECT:
4662 case K_START:
4663 ConnectClause();
4664 if( jjtn000 != null) jjtn000.connect = true;
4665 break;
4666 default:
4667 jj_la1[130] = jj_gen;
4668 ;
4669 }
4670 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4671 case K_GROUP:
4672 GroupByClause();
4673 if( jjtn000 != null) jjtn000.groupBy = true;
4674 break;
4675 default:
4676 jj_la1[131] = jj_gen;
4677 ;
4678 }
4679 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4680 case K_INTERSECT:
4681 case K_MINUS:
4682 case K_UNION:
4683 SetClause();
4684 if( jjtn000 != null) jjtn000.setClause = true;
4685 break;
4686 default:
4687 jj_la1[132] = jj_gen;
4688 ;
4689 }
4690 jjtree.closeNodeScope(jjtn000, true);
4691 jjtc000 = false;
4692 jjtreeCloseNodeScope(jjtn000);
4693 {if (true) return jjtn000;}
4694 } catch (Throwable jjte000) {
4695 if (jjtc000) {
4696 jjtree.clearNodeScope(jjtn000);
4697 jjtc000 = false;
4698 } else {
4699 jjtree.popNode();
4700 }
4701 if (jjte000 instanceof RuntimeException) {
4702 {if (true) throw (RuntimeException)jjte000;}
4703 }
4704 if (jjte000 instanceof ParseException) {
4705 {if (true) throw (ParseException)jjte000;}
4706 }
4707 {if (true) throw (Error)jjte000;}
4708 } finally {
4709 if (jjtc000) {
4710 jjtree.closeNodeScope(jjtn000, true);
4711 jjtreeCloseNodeScope(jjtn000);
4712 }
4713 }
4714 throw new Error("Missing return statement in function");
4715 }
4716
4717 // Checks for whatever follows SELECT
4718 static final public void SelectList(ASTQueryStatement query) throws ParseException {
4719 /*@bgen(jjtree) SelectList */
4720 ASTSelectList jjtn000 = new ASTSelectList(JJTSELECTLIST);
4721 boolean jjtc000 = true;
4722 jjtree.openNodeScope(jjtn000);
4723 jjtreeOpenNodeScope(jjtn000);
4724 try {
4725 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4726 case 173:
4727 jj_consume_token(173);
4728 jjtree.closeNodeScope(jjtn000, true);
4729 jjtc000 = false;
4730 jjtreeCloseNodeScope(jjtn000);
4731 if( query != null) query.selectAll = true;
4732 break;
4733 case K_CURSYSDATE:
4734 case K_NEWUID:
4735 case K_NULL:
4736 case K_SYSDATE:
4737 case S_NUMBER:
4738 case S_IDENTIFIER:
4739 case S_BIND:
4740 case S_CHAR_LITERAL:
4741 case S_QUOTED_IDENTIFIER:
4742 case 163:
4743 case 170:
4744 case 171:
4745 SelectItem(query);
4746 label_21:
4747 while (true) {
4748 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4749 case 164:
4750 ;
4751 break;
4752 default:
4753 jj_la1[133] = jj_gen;
4754 break label_21;
4755 }
4756 jj_consume_token(164);
4757 SelectItem(query);
4758 }
4759 break;
4760 default:
4761 jj_la1[134] = jj_gen;
4762 jj_consume_token(-1);
4763 throw new ParseException();
4764 }
4765 } catch (Throwable jjte000) {
4766 if (jjtc000) {
4767 jjtree.clearNodeScope(jjtn000);
4768 jjtc000 = false;
4769 } else {
4770 jjtree.popNode();
4771 }
4772 if (jjte000 instanceof RuntimeException) {
4773 {if (true) throw (RuntimeException)jjte000;}
4774 }
4775 if (jjte000 instanceof ParseException) {
4776 {if (true) throw (ParseException)jjte000;}
4777 }
4778 {if (true) throw (Error)jjte000;}
4779 } finally {
4780 if (jjtc000) {
4781 jjtree.closeNodeScope(jjtn000, true);
4782 jjtreeCloseNodeScope(jjtn000);
4783 }
4784 }
4785 }
4786
4787 static final public void SelectItem(ASTQueryStatement query) throws ParseException {
4788 /*@bgen(jjtree) SelectItem */
4789 ASTSelectItem jjtn000 = new ASTSelectItem(JJTSELECTITEM);
4790 boolean jjtc000 = true;
4791 jjtree.openNodeScope(jjtn000);
4792 jjtreeOpenNodeScope(jjtn000);SimpleNode expr;
4793 try {
4794 if (jj_2_10(2)) {
4795 OracleObjectName();
4796 jj_consume_token(176);
4797 jjtree.closeNodeScope(jjtn000, true);
4798 jjtc000 = false;
4799 jjtreeCloseNodeScope(jjtn000);
4800 if( query != null) query.selectAll = true;
4801 } else if (jj_2_11(4)) {
4802 OracleObjectName();
4803 jj_consume_token(160);
4804 OracleObjectName();
4805 jj_consume_token(176);
4806 jjtree.closeNodeScope(jjtn000, true);
4807 jjtc000 = false;
4808 jjtreeCloseNodeScope(jjtn000);
4809 if( query != null) query.selectAll = true;
4810 } else {
4811 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4812 case K_CURSYSDATE:
4813 case K_NEWUID:
4814 case K_NULL:
4815 case K_SYSDATE:
4816 case S_NUMBER:
4817 case S_IDENTIFIER:
4818 case S_BIND:
4819 case S_CHAR_LITERAL:
4820 case S_QUOTED_IDENTIFIER:
4821 case 163:
4822 case 170:
4823 case 171:
4824 expr = SQLSimpleExpression();
4825 if( query != null) query.what.addElement( expr);
4826 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4827 case S_IDENTIFIER:
4828 jj_consume_token(S_IDENTIFIER);
4829 break;
4830 default:
4831 jj_la1[135] = jj_gen;
4832 ;
4833 }
4834 break;
4835 default:
4836 jj_la1[136] = jj_gen;
4837 jj_consume_token(-1);
4838 throw new ParseException();
4839 }
4840 }
4841 } catch (Throwable jjte000) {
4842 if (jjtc000) {
4843 jjtree.clearNodeScope(jjtn000);
4844 jjtc000 = false;
4845 } else {
4846 jjtree.popNode();
4847 }
4848 if (jjte000 instanceof RuntimeException) {
4849 {if (true) throw (RuntimeException)jjte000;}
4850 }
4851 if (jjte000 instanceof ParseException) {
4852 {if (true) throw (ParseException)jjte000;}
4853 }
4854 {if (true) throw (Error)jjte000;}
4855 } finally {
4856 if (jjtc000) {
4857 jjtree.closeNodeScope(jjtn000, true);
4858 jjtreeCloseNodeScope(jjtn000);
4859 }
4860 }
4861 }
4862
4863 static final public ASTIntoClause IntoClause(java.util.Vector into) throws ParseException {
4864 /*@bgen(jjtree) IntoClause */
4865 ASTIntoClause jjtn000 = new ASTIntoClause(JJTINTOCLAUSE);
4866 boolean jjtc000 = true;
4867 jjtree.openNodeScope(jjtn000);
4868 jjtreeOpenNodeScope(jjtn000);
4869 try {
4870 jj_consume_token(K_INTO);
4871 IntoItem(into);
4872 label_22:
4873 while (true) {
4874 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4875 case 164:
4876 ;
4877 break;
4878 default:
4879 jj_la1[137] = jj_gen;
4880 break label_22;
4881 }
4882 jj_consume_token(164);
4883 IntoItem(into);
4884 }
4885 jjtree.closeNodeScope(jjtn000, true);
4886 jjtc000 = false;
4887 jjtreeCloseNodeScope(jjtn000);
4888 {if (true) return jjtn000;}
4889 } catch (Throwable jjte000) {
4890 if (jjtc000) {
4891 jjtree.clearNodeScope(jjtn000);
4892 jjtc000 = false;
4893 } else {
4894 jjtree.popNode();
4895 }
4896 if (jjte000 instanceof RuntimeException) {
4897 {if (true) throw (RuntimeException)jjte000;}
4898 }
4899 if (jjte000 instanceof ParseException) {
4900 {if (true) throw (ParseException)jjte000;}
4901 }
4902 {if (true) throw (Error)jjte000;}
4903 } finally {
4904 if (jjtc000) {
4905 jjtree.closeNodeScope(jjtn000, true);
4906 jjtreeCloseNodeScope(jjtn000);
4907 }
4908 }
4909 throw new Error("Missing return statement in function");
4910 }
4911
4912 static final public void IntoItem(java.util.Vector into) throws ParseException {
4913 /*@bgen(jjtree) IntoItem */
4914 ASTIntoItem jjtn000 = new ASTIntoItem(JJTINTOITEM);
4915 boolean jjtc000 = true;
4916 jjtree.openNodeScope(jjtn000);
4917 jjtreeOpenNodeScope(jjtn000);Token t;
4918 try {
4919 t = jj_consume_token(S_IDENTIFIER);
4920 jjtree.closeNodeScope(jjtn000, true);
4921 jjtc000 = false;
4922 jjtreeCloseNodeScope(jjtn000);
4923 if( into != null) into.addElement( t.image);
4924 } finally {
4925 if (jjtc000) {
4926 jjtree.closeNodeScope(jjtn000, true);
4927 jjtreeCloseNodeScope(jjtn000);
4928 }
4929 }
4930 }
4931
4932 static final public void FromClause(java.util.Vector from, java.util.Vector fromid) throws ParseException {
4933 /*@bgen(jjtree) FromClause */
4934 ASTFromClause jjtn000 = new ASTFromClause(JJTFROMCLAUSE);
4935 boolean jjtc000 = true;
4936 jjtree.openNodeScope(jjtn000);
4937 jjtreeOpenNodeScope(jjtn000);
4938 try {
4939 jj_consume_token(K_FROM);
4940 FromItem(from, fromid);
4941 label_23:
4942 while (true) {
4943 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4944 case 164:
4945 ;
4946 break;
4947 default:
4948 jj_la1[138] = jj_gen;
4949 break label_23;
4950 }
4951 jj_consume_token(164);
4952 FromItem(from, fromid);
4953 }
4954 } catch (Throwable jjte000) {
4955 if (jjtc000) {
4956 jjtree.clearNodeScope(jjtn000);
4957 jjtc000 = false;
4958 } else {
4959 jjtree.popNode();
4960 }
4961 if (jjte000 instanceof RuntimeException) {
4962 {if (true) throw (RuntimeException)jjte000;}
4963 }
4964 if (jjte000 instanceof ParseException) {
4965 {if (true) throw (ParseException)jjte000;}
4966 }
4967 {if (true) throw (Error)jjte000;}
4968 } finally {
4969 if (jjtc000) {
4970 jjtree.closeNodeScope(jjtn000, true);
4971 jjtreeCloseNodeScope(jjtn000);
4972 }
4973 }
4974 }
4975
4976 static final public void FromItem(java.util.Vector from, java.util.Vector fromid) throws ParseException {
4977 /*@bgen(jjtree) FromItem */
4978 ASTFromItem jjtn000 = new ASTFromItem(JJTFROMITEM);
4979 boolean jjtc000 = true;
4980 jjtree.openNodeScope(jjtn000);
4981 jjtreeOpenNodeScope(jjtn000);ASTTableReference expr;
4982 Token t;
4983 try {
4984 expr = TableReference();
4985 if( from != null) from.addElement( expr);
4986 t = null;
4987 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4988 case S_IDENTIFIER:
4989 t = jj_consume_token(S_IDENTIFIER);
4990 break;
4991 default:
4992 jj_la1[139] = jj_gen;
4993 ;
4994 }
4995 jjtree.closeNodeScope(jjtn000, true);
4996 jjtc000 = false;
4997 jjtreeCloseNodeScope(jjtn000);
4998 if( from != null && fromid != null) {
4999 if( t == null)
5000 fromid.addElement( "");
5001 else
5002 fromid.addElement(t.image);
5003 }
5004 } catch (Throwable jjte000) {
5005 if (jjtc000) {
5006 jjtree.clearNodeScope(jjtn000);
5007 jjtc000 = false;
5008 } else {
5009 jjtree.popNode();
5010 }
5011 if (jjte000 instanceof RuntimeException) {
5012 {if (true) throw (RuntimeException)jjte000;}
5013 }
5014 if (jjte000 instanceof ParseException) {
5015 {if (true) throw (ParseException)jjte000;}
5016 }
5017 {if (true) throw (Error)jjte000;}
5018 } finally {
5019 if (jjtc000) {
5020 jjtree.closeNodeScope(jjtn000, true);
5021 jjtreeCloseNodeScope(jjtn000);
5022 }
5023 }
5024 }
5025
5026 static final public ASTSQLExpression WhereClause() throws ParseException {
5027 /*@bgen(jjtree) WhereClause */
5028 ASTWhereClause jjtn000 = new ASTWhereClause(JJTWHERECLAUSE);
5029 boolean jjtc000 = true;
5030 jjtree.openNodeScope(jjtn000);
5031 jjtreeOpenNodeScope(jjtn000);ASTSQLExpression expr;
5032 try {
5033 jj_consume_token(K_WHERE);
5034 expr = SQLExpression();
5035 jjtree.closeNodeScope(jjtn000, true);
5036 jjtc000 = false;
5037 jjtreeCloseNodeScope(jjtn000);
5038 {if (true) return expr;}
5039 } catch (Throwable jjte000) {
5040 if (jjtc000) {
5041 jjtree.clearNodeScope(jjtn000);
5042 jjtc000 = false;
5043 } else {
5044 jjtree.popNode();
5045 }
5046 if (jjte000 instanceof RuntimeException) {
5047 {if (true) throw (RuntimeException)jjte000;}
5048 }
5049 if (jjte000 instanceof ParseException) {
5050 {if (true) throw (ParseException)jjte000;}
5051 }
5052 {if (true) throw (Error)jjte000;}
5053 } finally {
5054 if (jjtc000) {
5055 jjtree.closeNodeScope(jjtn000, true);
5056 jjtreeCloseNodeScope(jjtn000);
5057 }
5058 }
5059 throw new Error("Missing return statement in function");
5060 }
5061
5062 static final public void ConnectClause() throws ParseException {
5063 /*@bgen(jjtree) ConnectClause */
5064 ASTConnectClause jjtn000 = new ASTConnectClause(JJTCONNECTCLAUSE);
5065 boolean jjtc000 = true;
5066 jjtree.openNodeScope(jjtn000);
5067 jjtreeOpenNodeScope(jjtn000);
5068 try {
5069 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5070 case K_START:
5071 jj_consume_token(K_START);
5072 jj_consume_token(K_WITH);
5073 SQLExpression();
5074 break;
5075 default:
5076 jj_la1[140] = jj_gen;
5077 ;
5078 }
5079 jj_consume_token(K_CONNECT);
5080 jj_consume_token(K_BY);
5081 SQLExpression();
5082 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5083 case K_START:
5084 jj_consume_token(K_START);
5085 jj_consume_token(K_WITH);
5086 SQLExpression();
5087 break;
5088 default:
5089 jj_la1[141] = jj_gen;
5090 ;
5091 }
5092 } catch (Throwable jjte000) {
5093 if (jjtc000) {
5094 jjtree.clearNodeScope(jjtn000);
5095 jjtc000 = false;
5096 } else {
5097 jjtree.popNode();
5098 }
5099 if (jjte000 instanceof RuntimeException) {
5100 {if (true) throw (RuntimeException)jjte000;}
5101 }
5102 if (jjte000 instanceof ParseException) {
5103 {if (true) throw (ParseException)jjte000;}
5104 }
5105 {if (true) throw (Error)jjte000;}
5106 } finally {
5107 if (jjtc000) {
5108 jjtree.closeNodeScope(jjtn000, true);
5109 jjtreeCloseNodeScope(jjtn000);
5110 }
5111 }
5112 }
5113
5114 static final public void GroupByClause() throws ParseException {
5115 /*@bgen(jjtree) GroupByClause */
5116 ASTGroupByClause jjtn000 = new ASTGroupByClause(JJTGROUPBYCLAUSE);
5117 boolean jjtc000 = true;
5118 jjtree.openNodeScope(jjtn000);
5119 jjtreeOpenNodeScope(jjtn000);
5120 try {
5121 jj_consume_token(K_GROUP);
5122 jj_consume_token(K_BY);
5123 SQLExpressionList(null);
5124 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5125 case K_HAVING:
5126 jj_consume_token(K_HAVING);
5127 SQLExpression();
5128 break;
5129 default:
5130 jj_la1[142] = jj_gen;
5131 ;
5132 }
5133 } catch (Throwable jjte000) {
5134 if (jjtc000) {
5135 jjtree.clearNodeScope(jjtn000);
5136 jjtc000 = false;
5137 } else {
5138 jjtree.popNode();
5139 }
5140 if (jjte000 instanceof RuntimeException) {
5141 {if (true) throw (RuntimeException)jjte000;}
5142 }
5143 if (jjte000 instanceof ParseException) {
5144 {if (true) throw (ParseException)jjte000;}
5145 }
5146 {if (true) throw (Error)jjte000;}
5147 } finally {
5148 if (jjtc000) {
5149 jjtree.closeNodeScope(jjtn000, true);
5150 jjtreeCloseNodeScope(jjtn000);
5151 }
5152 }
5153 }
5154
5155 static final public void SetClause() throws ParseException {
5156 /*@bgen(jjtree) SetClause */
5157 ASTSetClause jjtn000 = new ASTSetClause(JJTSETCLAUSE);
5158 boolean jjtc000 = true;
5159 jjtree.openNodeScope(jjtn000);
5160 jjtreeOpenNodeScope(jjtn000);
5161 try {
5162 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5163 case K_UNION:
5164 jj_consume_token(K_UNION);
5165 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5166 case K_ALL:
5167 jj_consume_token(K_ALL);
5168 break;
5169 default:
5170 jj_la1[143] = jj_gen;
5171 ;
5172 }
5173 break;
5174 case K_INTERSECT:
5175 jj_consume_token(K_INTERSECT);
5176 break;
5177 case K_MINUS:
5178 jj_consume_token(K_MINUS);
5179 break;
5180 default:
5181 jj_la1[144] = jj_gen;
5182 jj_consume_token(-1);
5183 throw new ParseException();
5184 }
5185 if (jj_2_12(2147483647)) {
5186 jj_consume_token(163);
5187 SelectWithoutOrder(null);
5188 jj_consume_token(165);
5189 } else {
5190 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5191 case K_SELECT:
5192 SelectWithoutOrder(null);
5193 break;
5194 default:
5195 jj_la1[145] = jj_gen;
5196 jj_consume_token(-1);
5197 throw new ParseException();
5198 }
5199 }
5200 } catch (Throwable jjte000) {
5201 if (jjtc000) {
5202 jjtree.clearNodeScope(jjtn000);
5203 jjtc000 = false;
5204 } else {
5205 jjtree.popNode();
5206 }
5207 if (jjte000 instanceof RuntimeException) {
5208 {if (true) throw (RuntimeException)jjte000;}
5209 }
5210 if (jjte000 instanceof ParseException) {
5211 {if (true) throw (ParseException)jjte000;}
5212 }
5213 {if (true) throw (Error)jjte000;}
5214 } finally {
5215 if (jjtc000) {
5216 jjtree.closeNodeScope(jjtn000, true);
5217 jjtreeCloseNodeScope(jjtn000);
5218 }
5219 }
5220 }
5221
5222 static final public void OrderByClause() throws ParseException {
5223 /*@bgen(jjtree) OrderByClause */
5224 ASTOrderByClause jjtn000 = new ASTOrderByClause(JJTORDERBYCLAUSE);
5225 boolean jjtc000 = true;
5226 jjtree.openNodeScope(jjtn000);
5227 jjtreeOpenNodeScope(jjtn000);
5228 try {
5229 jj_consume_token(K_ORDER);
5230 jj_consume_token(K_BY);
5231 SQLSimpleExpression();
5232 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5233 case K_ASC:
5234 case K_DESC:
5235 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5236 case K_ASC:
5237 jj_consume_token(K_ASC);
5238 break;
5239 case K_DESC:
5240 jj_consume_token(K_DESC);
5241 break;
5242 default:
5243 jj_la1[146] = jj_gen;
5244 jj_consume_token(-1);
5245 throw new ParseException();
5246 }
5247 break;
5248 default:
5249 jj_la1[147] = jj_gen;
5250 ;
5251 }
5252 label_24:
5253 while (true) {
5254 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5255 case 164:
5256 ;
5257 break;
5258 default:
5259 jj_la1[148] = jj_gen;
5260 break label_24;
5261 }
5262 jj_consume_token(164);
5263 SQLSimpleExpression();
5264 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5265 case K_ASC:
5266 case K_DESC:
5267 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5268 case K_ASC:
5269 jj_consume_token(K_ASC);
5270 break;
5271 case K_DESC:
5272 jj_consume_token(K_DESC);
5273 break;
5274 default:
5275 jj_la1[149] = jj_gen;
5276 jj_consume_token(-1);
5277 throw new ParseException();
5278 }
5279 break;
5280 default:
5281 jj_la1[150] = jj_gen;
5282 ;
5283 }
5284 }
5285 } catch (Throwable jjte000) {
5286 if (jjtc000) {
5287 jjtree.clearNodeScope(jjtn000);
5288 jjtc000 = false;
5289 } else {
5290 jjtree.popNode();
5291 }
5292 if (jjte000 instanceof RuntimeException) {
5293 {if (true) throw (RuntimeException)jjte000;}
5294 }
5295 if (jjte000 instanceof ParseException) {
5296 {if (true) throw (ParseException)jjte000;}
5297 }
5298 {if (true) throw (Error)jjte000;}
5299 } finally {
5300 if (jjtc000) {
5301 jjtree.closeNodeScope(jjtn000, true);
5302 jjtreeCloseNodeScope(jjtn000);
5303 }
5304 }
5305 }
5306
5307 static final public void ForUpdateClause() throws ParseException {
5308 /*@bgen(jjtree) ForUpdateClause */
5309 ASTForUpdateClause jjtn000 = new ASTForUpdateClause(JJTFORUPDATECLAUSE);
5310 boolean jjtc000 = true;
5311 jjtree.openNodeScope(jjtn000);
5312 jjtreeOpenNodeScope(jjtn000);
5313 try {
5314 jj_consume_token(K_FOR);
5315 jj_consume_token(K_UPDATE);
5316 jj_consume_token(K_OF);
5317 TableColumn();
5318 label_25:
5319 while (true) {
5320 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5321 case 164:
5322 ;
5323 break;
5324 default:
5325 jj_la1[151] = jj_gen;
5326 break label_25;
5327 }
5328 jj_consume_token(164);
5329 TableColumn();
5330 }
5331 } catch (Throwable jjte000) {
5332 if (jjtc000) {
5333 jjtree.clearNodeScope(jjtn000);
5334 jjtc000 = false;
5335 } else {
5336 jjtree.popNode();
5337 }
5338 if (jjte000 instanceof RuntimeException) {
5339 {if (true) throw (RuntimeException)jjte000;}
5340 }
5341 if (jjte000 instanceof ParseException) {
5342 {if (true) throw (ParseException)jjte000;}
5343 }
5344 {if (true) throw (Error)jjte000;}
5345 } finally {
5346 if (jjtc000) {
5347 jjtree.closeNodeScope(jjtn000, true);
5348 jjtreeCloseNodeScope(jjtn000);
5349 }
5350 }
5351 }
5352
5353 static final public ASTSQLExpression SQLExpression() throws ParseException {
5354 /*@bgen(jjtree) SQLExpression */
5355 ASTSQLExpression jjtn000 = new ASTSQLExpression(JJTSQLEXPRESSION);
5356 boolean jjtc000 = true;
5357 jjtree.openNodeScope(jjtn000);
5358 jjtreeOpenNodeScope(jjtn000);ASTSQLAndExpression expr;
5359 try {
5360 expr = SQLAndExpression();
5361 jjtn000.ors.addElement( expr);
5362 label_26:
5363 while (true) {
5364 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5365 case K_OR:
5366 ;
5367 break;
5368 default:
5369 jj_la1[152] = jj_gen;
5370 break label_26;
5371 }
5372 jj_consume_token(K_OR);
5373 expr = SQLAndExpression();
5374 jjtn000.ors.addElement( expr);
5375 }
5376 jjtree.closeNodeScope(jjtn000, true);
5377 jjtc000 = false;
5378 jjtreeCloseNodeScope(jjtn000);
5379 {if (true) return jjtn000;}
5380 } catch (Throwable jjte000) {
5381 if (jjtc000) {
5382 jjtree.clearNodeScope(jjtn000);
5383 jjtc000 = false;
5384 } else {
5385 jjtree.popNode();
5386 }
5387 if (jjte000 instanceof RuntimeException) {
5388 {if (true) throw (RuntimeException)jjte000;}
5389 }
5390 if (jjte000 instanceof ParseException) {
5391 {if (true) throw (ParseException)jjte000;}
5392 }
5393 {if (true) throw (Error)jjte000;}
5394 } finally {
5395 if (jjtc000) {
5396 jjtree.closeNodeScope(jjtn000, true);
5397 jjtreeCloseNodeScope(jjtn000);
5398 }
5399 }
5400 throw new Error("Missing return statement in function");
5401 }
5402
5403 static final public ASTSQLAndExpression SQLAndExpression() throws ParseException {
5404 /*@bgen(jjtree) SQLAndExpression */
5405 ASTSQLAndExpression jjtn000 = new ASTSQLAndExpression(JJTSQLANDEXPRESSION);
5406 boolean jjtc000 = true;
5407 jjtree.openNodeScope(jjtn000);
5408 jjtreeOpenNodeScope(jjtn000);ASTSQLUnaryLogicalExpression expr;
5409 try {
5410 expr = SQLUnaryLogicalExpression();
5411 jjtn000.ands.addElement(expr);
5412 label_27:
5413 while (true) {
5414 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5415 case K_AND:
5416 ;
5417 break;
5418 default:
5419 jj_la1[153] = jj_gen;
5420 break label_27;
5421 }
5422 jj_consume_token(K_AND);
5423 expr = SQLUnaryLogicalExpression();
5424 jjtn000.ands.addElement( expr);
5425 }
5426 jjtree.closeNodeScope(jjtn000, true);
5427 jjtc000 = false;
5428 jjtreeCloseNodeScope(jjtn000);
5429 {if (true) return jjtn000;}
5430 } catch (Throwable jjte000) {
5431 if (jjtc000) {
5432 jjtree.clearNodeScope(jjtn000);
5433 jjtc000 = false;
5434 } else {
5435 jjtree.popNode();
5436 }
5437 if (jjte000 instanceof RuntimeException) {
5438 {if (true) throw (RuntimeException)jjte000;}
5439 }
5440 if (jjte000 instanceof ParseException) {
5441 {if (true) throw (ParseException)jjte000;}
5442 }
5443 {if (true) throw (Error)jjte000;}
5444 } finally {
5445 if (jjtc000) {
5446 jjtree.closeNodeScope(jjtn000, true);
5447 jjtreeCloseNodeScope(jjtn000);
5448 }
5449 }
5450 throw new Error("Missing return statement in function");
5451 }
5452
5453 static final public ASTSQLUnaryLogicalExpression SQLUnaryLogicalExpression() throws ParseException {
5454 /*@bgen(jjtree) SQLUnaryLogicalExpression */
5455 ASTSQLUnaryLogicalExpression jjtn000 = new ASTSQLUnaryLogicalExpression(JJTSQLUNARYLOGICALEXPRESSION);
5456 boolean jjtc000 = true;
5457 jjtree.openNodeScope(jjtn000);
5458 jjtreeOpenNodeScope(jjtn000);
5459 try {
5460 if (jj_2_13(2)) {
5461 ExistsClause();
5462 jjtn000.existsExpr = true;
5463 } else {
5464 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5465 case K_CURSYSDATE:
5466 case K_NEWUID:
5467 case K_NOT:
5468 case K_NULL:
5469 case K_PRIOR:
5470 case K_SYSDATE:
5471 case S_NUMBER:
5472 case S_IDENTIFIER:
5473 case S_BIND:
5474 case S_CHAR_LITERAL:
5475 case S_QUOTED_IDENTIFIER:
5476 case 163:
5477 case 170:
5478 case 171:
5479 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5480 case K_NOT:
5481 jj_consume_token(K_NOT);
5482 jjtn000.not = true;
5483 break;
5484 default:
5485 jj_la1[154] = jj_gen;
5486 ;
5487 }
5488 jjtn000.expr = SQLRelationalExpression();
5489 break;
5490 default:
5491 jj_la1[155] = jj_gen;
5492 jj_consume_token(-1);
5493 throw new ParseException();
5494 }
5495 }
5496 jjtree.closeNodeScope(jjtn000, true);
5497 jjtc000 = false;
5498 jjtreeCloseNodeScope(jjtn000);
5499 {if (true) return jjtn000;}
5500 } catch (Throwable jjte000) {
5501 if (jjtc000) {
5502 jjtree.clearNodeScope(jjtn000);
5503 jjtc000 = false;
5504 } else {
5505 jjtree.popNode();
5506 }
5507 if (jjte000 instanceof RuntimeException) {
5508 {if (true) throw (RuntimeException)jjte000;}
5509 }
5510 if (jjte000 instanceof ParseException) {
5511 {if (true) throw (ParseException)jjte000;}
5512 }
5513 {if (true) throw (Error)jjte000;}
5514 } finally {
5515 if (jjtc000) {
5516 jjtree.closeNodeScope(jjtn000, true);
5517 jjtreeCloseNodeScope(jjtn000);
5518 }
5519 }
5520 throw new Error("Missing return statement in function");
5521 }
5522
5523 static final public void ExistsClause() throws ParseException {
5524 /*@bgen(jjtree) ExistsClause */
5525 ASTExistsClause jjtn000 = new ASTExistsClause(JJTEXISTSCLAUSE);
5526 boolean jjtc000 = true;
5527 jjtree.openNodeScope(jjtn000);
5528 jjtreeOpenNodeScope(jjtn000);
5529 try {
5530 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5531 case K_NOT:
5532 jj_consume_token(K_NOT);
5533 break;
5534 default:
5535 jj_la1[156] = jj_gen;
5536 ;
5537 }
5538 jj_consume_token(K_EXISTS);
5539 jj_consume_token(163);
5540 SubQuery();
5541 jj_consume_token(165);
5542 } catch (Throwable jjte000) {
5543 if (jjtc000) {
5544 jjtree.clearNodeScope(jjtn000);
5545 jjtc000 = false;
5546 } else {
5547 jjtree.popNode();
5548 }
5549 if (jjte000 instanceof RuntimeException) {
5550 {if (true) throw (RuntimeException)jjte000;}
5551 }
5552 if (jjte000 instanceof ParseException) {
5553 {if (true) throw (ParseException)jjte000;}
5554 }
5555 {if (true) throw (Error)jjte000;}
5556 } finally {
5557 if (jjtc000) {
5558 jjtree.closeNodeScope(jjtn000, true);
5559 jjtreeCloseNodeScope(jjtn000);
5560 }
5561 }
5562 }
5563
5564 static final public ASTSQLRelationalExpression SQLRelationalExpression() throws ParseException {
5565 /*@bgen(jjtree) SQLRelationalExpression */
5566 ASTSQLRelationalExpression jjtn000 = new ASTSQLRelationalExpression(JJTSQLRELATIONALEXPRESSION);
5567 boolean jjtc000 = true;
5568 jjtree.openNodeScope(jjtn000);
5569 jjtreeOpenNodeScope(jjtn000);
5570 try {
5571 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5572 case K_PRIOR:
5573 jj_consume_token(K_PRIOR);
5574 jjtn000.firstprior = true;
5575 break;
5576 default:
5577 jj_la1[157] = jj_gen;
5578 ;
5579 }
5580 jjtn000.first = SQLSimpleExpression();
5581 jjtn000.type = 0;
5582 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5583 case K_BETWEEN:
5584 case K_IN:
5585 case K_IS:
5586 case K_LIKE:
5587 case K_NOT:
5588 case 153:
5589 case 154:
5590 case 155:
5591 case 156:
5592 case 157:
5593 case 158:
5594 case 159:
5595 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5596 case 153:
5597 case 154:
5598 case 155:
5599 case 156:
5600 case 157:
5601 case 158:
5602 case 159:
5603 SQLRelationalOperatorExpression(jjtn000);
5604 jjtn000.type = 1;
5605 break;
5606 default:
5607 jj_la1[158] = jj_gen;
5608 if (jj_2_14(2)) {
5609 SQLInClause();
5610 jjtn000.type = 2;
5611 } else if (jj_2_15(2)) {
5612 SQLBetweenClause();
5613 jjtn000.type = 3;
5614 } else if (jj_2_16(2)) {
5615 SQLLikeClause();
5616 jjtn000.type = 4;
5617 } else {
5618 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5619 case K_IS:
5620 IsNullClause();
5621 jjtn000.type = 5;
5622 break;
5623 default:
5624 jj_la1[159] = jj_gen;
5625 jj_consume_token(-1);
5626 throw new ParseException();
5627 }
5628 }
5629 }
5630 break;
5631 default:
5632 jj_la1[160] = jj_gen;
5633 ;
5634 }
5635 jjtree.closeNodeScope(jjtn000, true);
5636 jjtc000 = false;
5637 jjtreeCloseNodeScope(jjtn000);
5638 {if (true) return jjtn000;}
5639 } catch (Throwable jjte000) {
5640 if (jjtc000) {
5641 jjtree.clearNodeScope(jjtn000);
5642 jjtc000 = false;
5643 } else {
5644 jjtree.popNode();
5645 }
5646 if (jjte000 instanceof RuntimeException) {
5647 {if (true) throw (RuntimeException)jjte000;}
5648 }
5649 if (jjte000 instanceof ParseException) {
5650 {if (true) throw (ParseException)jjte000;}
5651 }
5652 {if (true) throw (Error)jjte000;}
5653 } finally {
5654 if (jjtc000) {
5655 jjtree.closeNodeScope(jjtn000, true);
5656 jjtreeCloseNodeScope(jjtn000);
5657 }
5658 }
5659 throw new Error("Missing return statement in function");
5660 }
5661
5662 static final public void SQLExpressionList(java.util.Vector params) throws ParseException {
5663 /*@bgen(jjtree) SQLExpressionList */
5664 ASTSQLExpressionList jjtn000 = new ASTSQLExpressionList(JJTSQLEXPRESSIONLIST);
5665 boolean jjtc000 = true;
5666 jjtree.openNodeScope(jjtn000);
5667 jjtreeOpenNodeScope(jjtn000);ASTSQLSimpleExpression expr;
5668 try {
5669 expr = SQLSimpleExpression();
5670 if(params != null) params.add( expr);
5671 label_28:
5672 while (true) {
5673 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5674 case 164:
5675 ;
5676 break;
5677 default:
5678 jj_la1[161] = jj_gen;
5679 break label_28;
5680 }
5681 jj_consume_token(164);
5682 expr = SQLSimpleExpression();
5683 if(params != null) params.add( expr);
5684 }
5685 } catch (Throwable jjte000) {
5686 if (jjtc000) {
5687 jjtree.clearNodeScope(jjtn000);
5688 jjtc000 = false;
5689 } else {
5690 jjtree.popNode();
5691 }
5692 if (jjte000 instanceof RuntimeException) {
5693 {if (true) throw (RuntimeException)jjte000;}
5694 }
5695 if (jjte000 instanceof ParseException) {
5696 {if (true) throw (ParseException)jjte000;}
5697 }
5698 {if (true) throw (Error)jjte000;}
5699 } finally {
5700 if (jjtc000) {
5701 jjtree.closeNodeScope(jjtn000, true);
5702 jjtreeCloseNodeScope(jjtn000);
5703 }
5704 }
5705 }
5706
5707 static final public void SQLRelationalOperatorExpression(ASTSQLRelationalExpression relexpr) throws ParseException {
5708 /*@bgen(jjtree) SQLRelationalOperatorExpression */
5709 ASTSQLRelationalOperatorExpression jjtn000 = new ASTSQLRelationalOperatorExpression(JJTSQLRELATIONALOPERATOREXPRESSION);
5710 boolean jjtc000 = true;
5711 jjtree.openNodeScope(jjtn000);
5712 jjtreeOpenNodeScope(jjtn000);
5713 try {
5714 relexpr.v1 = Relop();
5715 if (jj_2_17(2147483647)) {
5716 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5717 case K_ALL:
5718 case K_ANY:
5719 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5720 case K_ALL:
5721 jj_consume_token(K_ALL);
5722 break;
5723 case K_ANY:
5724 jj_consume_token(K_ANY);
5725 break;
5726 default:
5727 jj_la1[162] = jj_gen;
5728 jj_consume_token(-1);
5729 throw new ParseException();
5730 }
5731 break;
5732 default:
5733 jj_la1[163] = jj_gen;
5734 ;
5735 }
5736 jj_consume_token(163);
5737 SubQuery();
5738 jj_consume_token(165);
5739 jjtree.closeNodeScope(jjtn000, true);
5740 jjtc000 = false;
5741 jjtreeCloseNodeScope(jjtn000);
5742 relexpr.secondquery=true;
5743 } else {
5744 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5745 case K_CURSYSDATE:
5746 case K_NEWUID:
5747 case K_NULL:
5748 case K_PRIOR:
5749 case K_SYSDATE:
5750 case S_NUMBER:
5751 case S_IDENTIFIER:
5752 case S_BIND:
5753 case S_CHAR_LITERAL:
5754 case S_QUOTED_IDENTIFIER:
5755 case 163:
5756 case 170:
5757 case 171:
5758 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5759 case K_PRIOR:
5760 jj_consume_token(K_PRIOR);
5761 relexpr.secondprior = true;
5762 break;
5763 default:
5764 jj_la1[164] = jj_gen;
5765 ;
5766 }
5767 relexpr.v2 = SQLSimpleExpression();
5768 break;
5769 default:
5770 jj_la1[165] = jj_gen;
5771 jj_consume_token(-1);
5772 throw new ParseException();
5773 }
5774 }
5775 } catch (Throwable jjte000) {
5776 if (jjtc000) {
5777 jjtree.clearNodeScope(jjtn000);
5778 jjtc000 = false;
5779 } else {
5780 jjtree.popNode();
5781 }
5782 if (jjte000 instanceof RuntimeException) {
5783 {if (true) throw (RuntimeException)jjte000;}
5784 }
5785 if (jjte000 instanceof ParseException) {
5786 {if (true) throw (ParseException)jjte000;}
5787 }
5788 {if (true) throw (Error)jjte000;}
5789 } finally {
5790 if (jjtc000) {
5791 jjtree.closeNodeScope(jjtn000, true);
5792 jjtreeCloseNodeScope(jjtn000);
5793 }
5794 }
5795 }
5796
5797 static final public void SQLInClause() throws ParseException {
5798 /*@bgen(jjtree) SQLInClause */
5799 ASTSQLInClause jjtn000 = new ASTSQLInClause(JJTSQLINCLAUSE);
5800 boolean jjtc000 = true;
5801 jjtree.openNodeScope(jjtn000);
5802 jjtreeOpenNodeScope(jjtn000);
5803 try {
5804 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5805 case K_NOT:
5806 jj_consume_token(K_NOT);
5807 break;
5808 default:
5809 jj_la1[166] = jj_gen;
5810 ;
5811 }
5812 jj_consume_token(K_IN);
5813 jj_consume_token(163);
5814 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5815 case K_CURSYSDATE:
5816 case K_NEWUID:
5817 case K_NULL:
5818 case K_SYSDATE:
5819 case S_NUMBER:
5820 case S_IDENTIFIER:
5821 case S_BIND:
5822 case S_CHAR_LITERAL:
5823 case S_QUOTED_IDENTIFIER:
5824 case 163:
5825 case 170:
5826 case 171:
5827 SQLExpressionList(null);
5828 break;
5829 case K_SELECT:
5830 SubQuery();
5831 break;
5832 default:
5833 jj_la1[167] = jj_gen;
5834 jj_consume_token(-1);
5835 throw new ParseException();
5836 }
5837 jj_consume_token(165);
5838 } catch (Throwable jjte000) {
5839 if (jjtc000) {
5840 jjtree.clearNodeScope(jjtn000);
5841 jjtc000 = false;
5842 } else {
5843 jjtree.popNode();
5844 }
5845 if (jjte000 instanceof RuntimeException) {
5846 {if (true) throw (RuntimeException)jjte000;}
5847 }
5848 if (jjte000 instanceof ParseException) {
5849 {if (true) throw (ParseException)jjte000;}
5850 }
5851 {if (true) throw (Error)jjte000;}
5852 } finally {
5853 if (jjtc000) {
5854 jjtree.closeNodeScope(jjtn000, true);
5855 jjtreeCloseNodeScope(jjtn000);
5856 }
5857 }
5858 }
5859
5860 static final public void SQLBetweenClause() throws ParseException {
5861 /*@bgen(jjtree) SQLBetweenClause */
5862 ASTSQLBetweenClause jjtn000 = new ASTSQLBetweenClause(JJTSQLBETWEENCLAUSE);
5863 boolean jjtc000 = true;
5864 jjtree.openNodeScope(jjtn000);
5865 jjtreeOpenNodeScope(jjtn000);
5866 try {
5867 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5868 case K_NOT:
5869 jj_consume_token(K_NOT);
5870 break;
5871 default:
5872 jj_la1[168] = jj_gen;
5873 ;
5874 }
5875 jj_consume_token(K_BETWEEN);
5876 SQLSimpleExpression();
5877 jj_consume_token(K_AND);
5878 SQLSimpleExpression();
5879 } catch (Throwable jjte000) {
5880 if (jjtc000) {
5881 jjtree.clearNodeScope(jjtn000);
5882 jjtc000 = false;
5883 } else {
5884 jjtree.popNode();
5885 }
5886 if (jjte000 instanceof RuntimeException) {
5887 {if (true) throw (RuntimeException)jjte000;}
5888 }
5889 if (jjte000 instanceof ParseException) {
5890 {if (true) throw (ParseException)jjte000;}
5891 }
5892 {if (true) throw (Error)jjte000;}
5893 } finally {
5894 if (jjtc000) {
5895 jjtree.closeNodeScope(jjtn000, true);
5896 jjtreeCloseNodeScope(jjtn000);
5897 }
5898 }
5899 }
5900
5901 static final public void SQLLikeClause() throws ParseException {
5902 /*@bgen(jjtree) SQLLikeClause */
5903 ASTSQLLikeClause jjtn000 = new ASTSQLLikeClause(JJTSQLLIKECLAUSE);
5904 boolean jjtc000 = true;
5905 jjtree.openNodeScope(jjtn000);
5906 jjtreeOpenNodeScope(jjtn000);
5907 try {
5908 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5909 case K_NOT:
5910 jj_consume_token(K_NOT);
5911 break;
5912 default:
5913 jj_la1[169] = jj_gen;
5914 ;
5915 }
5916 jj_consume_token(K_LIKE);
5917 SQLSimpleExpression();
5918 } catch (Throwable jjte000) {
5919 if (jjtc000) {
5920 jjtree.clearNodeScope(jjtn000);
5921 jjtc000 = false;
5922 } else {
5923 jjtree.popNode();
5924 }
5925 if (jjte000 instanceof RuntimeException) {
5926 {if (true) throw (RuntimeException)jjte000;}
5927 }
5928 if (jjte000 instanceof ParseException) {
5929 {if (true) throw (ParseException)jjte000;}
5930 }
5931 {if (true) throw (Error)jjte000;}
5932 } finally {
5933 if (jjtc000) {
5934 jjtree.closeNodeScope(jjtn000, true);
5935 jjtreeCloseNodeScope(jjtn000);
5936 }
5937 }
5938 }
5939
5940 static final public ASTSQLSimpleExpression SQLSimpleExpression() throws ParseException {
5941 /*@bgen(jjtree) SQLSimpleExpression */
5942 ASTSQLSimpleExpression jjtn000 = new ASTSQLSimpleExpression(JJTSQLSIMPLEEXPRESSION);
5943 boolean jjtc000 = true;
5944 jjtree.openNodeScope(jjtn000);
5945 jjtreeOpenNodeScope(jjtn000);ASTSQLMultiplicativeExpression expr;
5946 byte opType;
5947 try {
5948 jjtn000.first = SQLMultiplicativeExpression();
5949 label_29:
5950 while (true) {
5951 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5952 case 170:
5953 case 171:
5954 case 172:
5955 ;
5956 break;
5957 default:
5958 jj_la1[170] = jj_gen;
5959 break label_29;
5960 }
5961 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5962 case 170:
5963 jj_consume_token(170);
5964 opType = jjtn000.OP_PLUS;
5965 break;
5966 case 171:
5967 jj_consume_token(171);
5968 opType = jjtn000.OP_MINUS;
5969 break;
5970 case 172:
5971 jj_consume_token(172);
5972 opType = jjtn000.OP_OR;
5973 break;
5974 default:
5975 jj_la1[171] = jj_gen;
5976 jj_consume_token(-1);
5977 throw new ParseException();
5978 }
5979 expr = SQLMultiplicativeExpression();
5980 jjtn000.insert( opType, expr);
5981 }
5982 jjtree.closeNodeScope(jjtn000, true);
5983 jjtc000 = false;
5984 jjtreeCloseNodeScope(jjtn000);
5985 {if (true) return jjtn000;}
5986 } catch (Throwable jjte000) {
5987 if (jjtc000) {
5988 jjtree.clearNodeScope(jjtn000);
5989 jjtc000 = false;
5990 } else {
5991 jjtree.popNode();
5992 }
5993 if (jjte000 instanceof RuntimeException) {
5994 {if (true) throw (RuntimeException)jjte000;}
5995 }
5996 if (jjte000 instanceof ParseException) {
5997 {if (true) throw (ParseException)jjte000;}
5998 }
5999 {if (true) throw (Error)jjte000;}
6000 } finally {
6001 if (jjtc000) {
6002 jjtree.closeNodeScope(jjtn000, true);
6003 jjtreeCloseNodeScope(jjtn000);
6004 }
6005 }
6006 throw new Error("Missing return statement in function");
6007 }
6008
6009 static final public ASTSQLMultiplicativeExpression SQLMultiplicativeExpression() throws ParseException {
6010 /*@bgen(jjtree) SQLMultiplicativeExpression */
6011 ASTSQLMultiplicativeExpression jjtn000 = new ASTSQLMultiplicativeExpression(JJTSQLMULTIPLICATIVEEXPRESSION);
6012 boolean jjtc000 = true;
6013 jjtree.openNodeScope(jjtn000);
6014 jjtreeOpenNodeScope(jjtn000);ASTSQLExpotentExpression expr;
6015 byte opType;
6016 try {
6017 jjtn000.first = SQLExpotentExpression();
6018 label_30:
6019 while (true) {
6020 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6021 case 173:
6022 case 174:
6023 ;
6024 break;
6025 default:
6026 jj_la1[172] = jj_gen;
6027 break label_30;
6028 }
6029 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6030 case 173:
6031 jj_consume_token(173);
6032 opType = jjtn000.OP_MULTI;
6033 break;
6034 case 174:
6035 jj_consume_token(174);
6036 opType = jjtn000.OP_DIVI;
6037 break;
6038 default:
6039 jj_la1[173] = jj_gen;
6040 jj_consume_token(-1);
6041 throw new ParseException();
6042 }
6043 expr = SQLExpotentExpression();
6044 jjtn000.insert( opType, expr);
6045 }
6046 jjtree.closeNodeScope(jjtn000, true);
6047 jjtc000 = false;
6048 jjtreeCloseNodeScope(jjtn000);
6049 {if (true) return jjtn000;}
6050 } catch (Throwable jjte000) {
6051 if (jjtc000) {
6052 jjtree.clearNodeScope(jjtn000);
6053 jjtc000 = false;
6054 } else {
6055 jjtree.popNode();
6056 }
6057 if (jjte000 instanceof RuntimeException) {
6058 {if (true) throw (RuntimeException)jjte000;}
6059 }
6060 if (jjte000 instanceof ParseException) {
6061 {if (true) throw (ParseException)jjte000;}
6062 }
6063 {if (true) throw (Error)jjte000;}
6064 } finally {
6065 if (jjtc000) {
6066 jjtree.closeNodeScope(jjtn000, true);
6067 jjtreeCloseNodeScope(jjtn000);
6068 }
6069 }
6070 throw new Error("Missing return statement in function");
6071 }
6072
6073 static final public ASTSQLExpotentExpression SQLExpotentExpression() throws ParseException {
6074 /*@bgen(jjtree) SQLExpotentExpression */
6075 ASTSQLExpotentExpression jjtn000 = new ASTSQLExpotentExpression(JJTSQLEXPOTENTEXPRESSION);
6076 boolean jjtc000 = true;
6077 jjtree.openNodeScope(jjtn000);
6078 jjtreeOpenNodeScope(jjtn000);ASTSQLUnaryExpression expr;
6079 try {
6080 expr = SQLUnaryExpression();
6081 jjtn000.els.addElement( expr);
6082 label_31:
6083 while (true) {
6084 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6085 case 175:
6086 ;
6087 break;
6088 default:
6089 jj_la1[174] = jj_gen;
6090 break label_31;
6091 }
6092 jj_consume_token(175);
6093 expr = SQLUnaryExpression();
6094 jjtn000.els.addElement( expr);
6095 }
6096 jjtree.closeNodeScope(jjtn000, true);
6097 jjtc000 = false;
6098 jjtreeCloseNodeScope(jjtn000);
6099 {if (true) return jjtn000;}
6100 } catch (Throwable jjte000) {
6101 if (jjtc000) {
6102 jjtree.clearNodeScope(jjtn000);
6103 jjtc000 = false;
6104 } else {
6105 jjtree.popNode();
6106 }
6107 if (jjte000 instanceof RuntimeException) {
6108 {if (true) throw (RuntimeException)jjte000;}
6109 }
6110 if (jjte000 instanceof ParseException) {
6111 {if (true) throw (ParseException)jjte000;}
6112 }
6113 {if (true) throw (Error)jjte000;}
6114 } finally {
6115 if (jjtc000) {
6116 jjtree.closeNodeScope(jjtn000, true);
6117 jjtreeCloseNodeScope(jjtn000);
6118 }
6119 }
6120 throw new Error("Missing return statement in function");
6121 }
6122
6123 static final public ASTSQLUnaryExpression SQLUnaryExpression() throws ParseException {
6124 /*@bgen(jjtree) SQLUnaryExpression */
6125 ASTSQLUnaryExpression jjtn000 = new ASTSQLUnaryExpression(JJTSQLUNARYEXPRESSION);
6126 boolean jjtc000 = true;
6127 jjtree.openNodeScope(jjtn000);
6128 jjtreeOpenNodeScope(jjtn000);
6129 try {
6130 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6131 case 170:
6132 case 171:
6133 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6134 case 170:
6135 jj_consume_token(170);
6136 jjtn000.sign = 1;
6137 break;
6138 case 171:
6139 jj_consume_token(171);
6140 jjtn000.sign = 2;
6141 break;
6142 default:
6143 jj_la1[175] = jj_gen;
6144 jj_consume_token(-1);
6145 throw new ParseException();
6146 }
6147 break;
6148 default:
6149 jj_la1[176] = jj_gen;
6150 ;
6151 }
6152 jjtn000.expr = SQLPrimaryExpression();
6153 jjtree.closeNodeScope(jjtn000, true);
6154 jjtc000 = false;
6155 jjtreeCloseNodeScope(jjtn000);
6156 {if (true) return jjtn000;}
6157 } catch (Throwable jjte000) {
6158 if (jjtc000) {
6159 jjtree.clearNodeScope(jjtn000);
6160 jjtc000 = false;
6161 } else {
6162 jjtree.popNode();
6163 }
6164 if (jjte000 instanceof RuntimeException) {
6165 {if (true) throw (RuntimeException)jjte000;}
6166 }
6167 if (jjte000 instanceof ParseException) {
6168 {if (true) throw (ParseException)jjte000;}
6169 }
6170 {if (true) throw (Error)jjte000;}
6171 } finally {
6172 if (jjtc000) {
6173 jjtree.closeNodeScope(jjtn000, true);
6174 jjtreeCloseNodeScope(jjtn000);
6175 }
6176 }
6177 throw new Error("Missing return statement in function");
6178 }
6179
6180 static final public ASTSQLPrimaryExpression SQLPrimaryExpression() throws ParseException {
6181 /*@bgen(jjtree) SQLPrimaryExpression */
6182 ASTSQLPrimaryExpression jjtn000 = new ASTSQLPrimaryExpression(JJTSQLPRIMARYEXPRESSION);
6183 boolean jjtc000 = true;
6184 jjtree.openNodeScope(jjtn000);
6185 jjtreeOpenNodeScope(jjtn000);Token t;
6186 try {
6187 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6188 case K_NULL:
6189 jj_consume_token(K_NULL);
6190 jjtn000.type = jjtn000.EXPR_NULL;
6191 break;
6192 default:
6193 jj_la1[177] = jj_gen;
6194 if (jj_2_18(2147483647)) {
6195 jjtn000.v1 = FunctionCall();
6196 jjtn000.type = jjtn000.EXPR_FUNCTION;
6197 } else if (jj_2_19(2147483647)) {
6198 OuterJoinExpression();
6199 jjtn000.type = jjtn000.EXPR_OUTERJOIN;
6200 } else {
6201 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6202 case S_IDENTIFIER:
6203 jjtn000.v1 = TableColumn();
6204 jjtn000.type = jjtn000.EXPR_VARIABLE;
6205 break;
6206 case K_SYSDATE:
6207 jj_consume_token(K_SYSDATE);
6208 jjtn000.type = jjtn000.EXPR_SYSDATE;
6209 break;
6210 case K_CURSYSDATE:
6211 jj_consume_token(K_CURSYSDATE);
6212 jjtn000.v1 = new java.util.Date(); jjtn000.type = jjtn000.EXPR_CURSYSDATE;
6213 break;
6214 case K_NEWUID:
6215 jj_consume_token(K_NEWUID);
6216 jjtn000.v1 = MobisnapSQL.uids.getNewUID(); jjtn000.type = jjtn000.EXPR_NEWUID;
6217 break;
6218 case S_NUMBER:
6219 t = jj_consume_token(S_NUMBER);
6220 jjtn000.v1 = t.image; jjtn000.type = jjtn000.EXPR_SQLNUMBER;
6221 break;
6222 case S_CHAR_LITERAL:
6223 t = jj_consume_token(S_CHAR_LITERAL);
6224 jjtn000.v1 = t.image.substring( 1, t.image.length() - 1);
6225 jjtn000.type = jjtn000.EXPR_SQLCHARLITERAL;
6226 break;
6227 case S_BIND:
6228 jj_consume_token(S_BIND);
6229 jjtn000.type = jjtn000.EXPR_SQLBIND;
6230 break;
6231 case 163:
6232 jj_consume_token(163);
6233 jjtn000.v1 = SQLExpression();
6234 jj_consume_token(165);
6235 jjtn000.type = jjtn000.EXPR_SQLEXPR;
6236 break;
6237 default:
6238 jj_la1[178] = jj_gen;
6239 jj_consume_token(-1);
6240 throw new ParseException();
6241 }
6242 }
6243 }
6244 jjtree.closeNodeScope(jjtn000, true);
6245 jjtc000 = false;
6246 jjtreeCloseNodeScope(jjtn000);
6247 {if (true) return jjtn000;}
6248 } catch (Throwable jjte000) {
6249 if (jjtc000) {
6250 jjtree.clearNodeScope(jjtn000);
6251 jjtc000 = false;
6252 } else {
6253 jjtree.popNode();
6254 }
6255 if (jjte000 instanceof RuntimeException) {
6256 {if (true) throw (RuntimeException)jjte000;}
6257 }
6258 if (jjte000 instanceof ParseException) {
6259 {if (true) throw (ParseException)jjte000;}
6260 }
6261 {if (true) throw (Error)jjte000;}
6262 } finally {
6263 if (jjtc000) {
6264 jjtree.closeNodeScope(jjtn000, true);
6265 jjtreeCloseNodeScope(jjtn000);
6266 }
6267 }
6268 throw new Error("Missing return statement in function");
6269 }
6270
6271 static final public ASTFunctionCall FunctionCall() throws ParseException {
6272 /*@bgen(jjtree) FunctionCall */
6273 ASTFunctionCall jjtn000 = new ASTFunctionCall(JJTFUNCTIONCALL);
6274 boolean jjtc000 = true;
6275 jjtree.openNodeScope(jjtn000);
6276 jjtreeOpenNodeScope(jjtn000);Token t;
6277 try {
6278 // caters the following
6279 // function(args)
6280 // package.function(args)
6281 // user.package.function(args)
6282
6283 // however note that "distinct/all/*" can be only used with
6284 // inbuilt functions but no distinction is made between inbuilt
6285 // function and custom functions
6286
6287 // OracleObjectName() [ "." OracleObjectName() ["." OracleObjectName()]]
6288 t = jj_consume_token(S_IDENTIFIER);
6289 jjtn000.name = t.image;
6290 jj_consume_token(163);
6291 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6292 case K_ALL:
6293 case K_CURSYSDATE:
6294 case K_DISTINCT:
6295 case K_NEWUID:
6296 case K_NULL:
6297 case K_SYSDATE:
6298 case S_NUMBER:
6299 case S_IDENTIFIER:
6300 case S_BIND:
6301 case S_CHAR_LITERAL:
6302 case S_QUOTED_IDENTIFIER:
6303 case 163:
6304 case 170:
6305 case 171:
6306 case 173:
6307 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6308 case K_ALL:
6309 case K_DISTINCT:
6310 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6311 case K_DISTINCT:
6312 jj_consume_token(K_DISTINCT);
6313 jjtn000.distinct = true;
6314 break;
6315 case K_ALL:
6316 jj_consume_token(K_ALL);
6317 jjtn000.all = true;
6318 break;
6319 default:
6320 jj_la1[179] = jj_gen;
6321 jj_consume_token(-1);
6322 throw new ParseException();
6323 }
6324 break;
6325 default:
6326 jj_la1[180] = jj_gen;
6327 ;
6328 }
6329 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6330 case K_CURSYSDATE:
6331 case K_NEWUID:
6332 case K_NULL:
6333 case K_SYSDATE:
6334 case S_NUMBER:
6335 case S_IDENTIFIER:
6336 case S_BIND:
6337 case S_CHAR_LITERAL:
6338 case S_QUOTED_IDENTIFIER:
6339 case 163:
6340 case 170:
6341 case 171:
6342 SQLArguments(jjtn000.params);
6343 break;
6344 case 173:
6345 jj_consume_token(173);
6346 jjtn000.wildcard = true;
6347 break;
6348 default:
6349 jj_la1[181] = jj_gen;
6350 jj_consume_token(-1);
6351 throw new ParseException();
6352 }
6353 break;
6354 default:
6355 jj_la1[182] = jj_gen;
6356 ;
6357 }
6358 jj_consume_token(165);
6359 jjtree.closeNodeScope(jjtn000, true);
6360 jjtc000 = false;
6361 jjtreeCloseNodeScope(jjtn000);
6362 {if (true) return jjtn000;}
6363 } catch (Throwable jjte000) {
6364 if (jjtc000) {
6365 jjtree.clearNodeScope(jjtn000);
6366 jjtc000 = false;
6367 } else {
6368 jjtree.popNode();
6369 }
6370 if (jjte000 instanceof RuntimeException) {
6371 {if (true) throw (RuntimeException)jjte000;}
6372 }
6373 if (jjte000 instanceof ParseException) {
6374 {if (true) throw (ParseException)jjte000;}
6375 }
6376 {if (true) throw (Error)jjte000;}
6377 } finally {
6378 if (jjtc000) {
6379 jjtree.closeNodeScope(jjtn000, true);
6380 jjtreeCloseNodeScope(jjtn000);
6381 }
6382 }
6383 throw new Error("Missing return statement in function");
6384 }
6385
6386 static final public void SQLArguments(java.util.Vector params) throws ParseException {
6387 /*@bgen(jjtree) SQLArguments */
6388 ASTSQLArguments jjtn000 = new ASTSQLArguments(JJTSQLARGUMENTS);
6389 boolean jjtc000 = true;
6390 jjtree.openNodeScope(jjtn000);
6391 jjtreeOpenNodeScope(jjtn000);
6392 try {
6393 SQLExpressionList(params);
6394 } catch (Throwable jjte000) {
6395 if (jjtc000) {
6396 jjtree.clearNodeScope(jjtn000);
6397 jjtc000 = false;
6398 } else {
6399 jjtree.popNode();
6400 }
6401 if (jjte000 instanceof RuntimeException) {
6402 {if (true) throw (RuntimeException)jjte000;}
6403 }
6404 if (jjte000 instanceof ParseException) {
6405 {if (true) throw (ParseException)jjte000;}
6406 }
6407 {if (true) throw (Error)jjte000;}
6408 } finally {
6409 if (jjtc000) {
6410 jjtree.closeNodeScope(jjtn000, true);
6411 jjtreeCloseNodeScope(jjtn000);
6412 }
6413 }
6414 }
6415
6416 static final public void OuterJoinExpression() throws ParseException {
6417 /*@bgen(jjtree) OuterJoinExpression */
6418 ASTOuterJoinExpression jjtn000 = new ASTOuterJoinExpression(JJTOUTERJOINEXPRESSION);
6419 boolean jjtc000 = true;
6420 jjtree.openNodeScope(jjtn000);
6421 jjtreeOpenNodeScope(jjtn000);
6422 try {
6423 OracleObjectName();
6424 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6425 case 160:
6426 jj_consume_token(160);
6427 OracleObjectName();
6428 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6429 case 160:
6430 jj_consume_token(160);
6431 OracleObjectName();
6432 break;
6433 default:
6434 jj_la1[183] = jj_gen;
6435 ;
6436 }
6437 break;
6438 default:
6439 jj_la1[184] = jj_gen;
6440 ;
6441 }
6442 jj_consume_token(163);
6443 jj_consume_token(170);
6444 jj_consume_token(165);
6445 } catch (Throwable jjte000) {
6446 if (jjtc000) {
6447 jjtree.clearNodeScope(jjtn000);
6448 jjtc000 = false;
6449 } else {
6450 jjtree.popNode();
6451 }
6452 if (jjte000 instanceof RuntimeException) {
6453 {if (true) throw (RuntimeException)jjte000;}
6454 }
6455 if (jjte000 instanceof ParseException) {
6456 {if (true) throw (ParseException)jjte000;}
6457 }
6458 {if (true) throw (Error)jjte000;}
6459 } finally {
6460 if (jjtc000) {
6461 jjtree.closeNodeScope(jjtn000, true);
6462 jjtreeCloseNodeScope(jjtn000);
6463 }
6464 }
6465 }
6466
6467 static final public void SubQuery() throws ParseException {
6468 /*@bgen(jjtree) SubQuery */
6469 ASTSubQuery jjtn000 = new ASTSubQuery(JJTSUBQUERY);
6470 boolean jjtc000 = true;
6471 jjtree.openNodeScope(jjtn000);
6472 jjtreeOpenNodeScope(jjtn000);
6473 try {
6474 SelectWithoutOrder(null);
6475 } catch (Throwable jjte000) {
6476 if (jjtc000) {
6477 jjtree.clearNodeScope(jjtn000);
6478 jjtc000 = false;
6479 } else {
6480 jjtree.popNode();
6481 }
6482 if (jjte000 instanceof RuntimeException) {
6483 {if (true) throw (RuntimeException)jjte000;}
6484 }
6485 if (jjte000 instanceof ParseException) {
6486 {if (true) throw (ParseException)jjte000;}
6487 }
6488 {if (true) throw (Error)jjte000;}
6489 } finally {
6490 if (jjtc000) {
6491 jjtree.closeNodeScope(jjtn000, true);
6492 jjtreeCloseNodeScope(jjtn000);
6493 }
6494 }
6495 }
6496
6497 static final private boolean jj_2_1(int xla) {
6498 jj_la = xla; jj_lastpos = jj_scanpos = token;
6499 boolean retval = !jj_3_1();
6500 jj_save(0, xla);
6501 return retval;
6502 }
6503
6504 static final private boolean jj_2_2(int xla) {
6505 jj_la = xla; jj_lastpos = jj_scanpos = token;
6506 boolean retval = !jj_3_2();
6507 jj_save(1, xla);
6508 return retval;
6509 }
6510
6511 static final private boolean jj_2_3(int xla) {
6512 jj_la = xla; jj_lastpos = jj_scanpos = token;
6513 boolean retval = !jj_3_3();
6514 jj_save(2, xla);
6515 return retval;
6516 }
6517
6518 static final private boolean jj_2_4(int xla) {
6519 jj_la = xla; jj_lastpos = jj_scanpos = token;
6520 boolean retval = !jj_3_4();
6521 jj_save(3, xla);
6522 return retval;
6523 }
6524
6525 static final private boolean jj_2_5(int xla) {
6526 jj_la = xla; jj_lastpos = jj_scanpos = token;
6527 boolean retval = !jj_3_5();
6528 jj_save(4, xla);
6529 return retval;
6530 }
6531
6532 static final private boolean jj_2_6(int xla) {
6533 jj_la = xla; jj_lastpos = jj_scanpos = token;
6534 boolean retval = !jj_3_6();
6535 jj_save(5, xla);
6536 return retval;
6537 }
6538
6539 static final private boolean jj_2_7(int xla) {
6540 jj_la = xla; jj_lastpos = jj_scanpos = token;
6541 boolean retval = !jj_3_7();
6542 jj_save(6, xla);
6543 return retval;
6544 }
6545
6546 static final private boolean jj_2_8(int xla) {
6547 jj_la = xla; jj_lastpos = jj_scanpos = token;
6548 boolean retval = !jj_3_8();
6549 jj_save(7, xla);
6550 return retval;
6551 }
6552
6553 static final private boolean jj_2_9(int xla) {
6554 jj_la = xla; jj_lastpos = jj_scanpos = token;
6555 boolean retval = !jj_3_9();
6556 jj_save(8, xla);
6557 return retval;
6558 }
6559
6560 static final private boolean jj_2_10(int xla) {
6561 jj_la = xla; jj_lastpos = jj_scanpos = token;
6562 boolean retval = !jj_3_10();
6563 jj_save(9, xla);
6564 return retval;
6565 }
6566
6567 static final private boolean jj_2_11(int xla) {
6568 jj_la = xla; jj_lastpos = jj_scanpos = token;
6569 boolean retval = !jj_3_11();
6570 jj_save(10, xla);
6571 return retval;
6572 }
6573
6574 static final private boolean jj_2_12(int xla) {
6575 jj_la = xla; jj_lastpos = jj_scanpos = token;
6576 boolean retval = !jj_3_12();
6577 jj_save(11, xla);
6578 return retval;
6579 }
6580
6581 static final private boolean jj_2_13(int xla) {
6582 jj_la = xla; jj_lastpos = jj_scanpos = token;
6583 boolean retval = !jj_3_13();
6584 jj_save(12, xla);
6585 return retval;
6586 }
6587
6588 static final private boolean jj_2_14(int xla) {
6589 jj_la = xla; jj_lastpos = jj_scanpos = token;
6590 boolean retval = !jj_3_14();
6591 jj_save(13, xla);
6592 return retval;
6593 }
6594
6595 static final private boolean jj_2_15(int xla) {
6596 jj_la = xla; jj_lastpos = jj_scanpos = token;
6597 boolean retval = !jj_3_15();
6598 jj_save(14, xla);
6599 return retval;
6600 }
6601
6602 static final private boolean jj_2_16(int xla) {
6603 jj_la = xla; jj_lastpos = jj_scanpos = token;
6604 boolean retval = !jj_3_16();
6605 jj_save(15, xla);
6606 return retval;
6607 }
6608
6609 static final private boolean jj_2_17(int xla) {
6610 jj_la = xla; jj_lastpos = jj_scanpos = token;
6611 boolean retval = !jj_3_17();
6612 jj_save(16, xla);
6613 return retval;
6614 }
6615
6616 static final private boolean jj_2_18(int xla) {
6617 jj_la = xla; jj_lastpos = jj_scanpos = token;
6618 boolean retval = !jj_3_18();
6619 jj_save(17, xla);
6620 return retval;
6621 }
6622
6623 static final private boolean jj_2_19(int xla) {
6624 jj_la = xla; jj_lastpos = jj_scanpos = token;
6625 boolean retval = !jj_3_19();
6626 jj_save(18, xla);
6627 return retval;
6628 }
6629
6630 static final private boolean jj_3R_84() {
6631 if (jj_3R_92()) return true;
6632 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6633 return false;
6634 }
6635
6636 static final private boolean jj_3R_82() {
6637 if (jj_scan_token(K_DISTINCT)) return true;
6638 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6639 return false;
6640 }
6641
6642 static final private boolean jj_3R_71() {
6643 Token xsp;
6644 xsp = jj_scanpos;
6645 if (jj_3R_82()) {
6646 jj_scanpos = xsp;
6647 if (jj_3R_83()) return true;
6648 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6649 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6650 return false;
6651 }
6652
6653 static final private boolean jj_3_6() {
6654 if (jj_3R_37()) return true;
6655 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6656 return false;
6657 }
6658
6659 static final private boolean jj_3R_85() {
6660 if (jj_3R_93()) return true;
6661 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6662 Token xsp;
6663 while (true) {
6664 xsp = jj_scanpos;
6665 if (jj_3R_94()) { jj_scanpos = xsp; break; }
6666 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6667 }
6668 return false;
6669 }
6670
6671 static final private boolean jj_3R_63() {
6672 Token xsp;
6673 xsp = jj_scanpos;
6674 if (jj_3R_71()) jj_scanpos = xsp;
6675 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6676 xsp = jj_scanpos;
6677 if (jj_3R_72()) {
6678 jj_scanpos = xsp;
6679 if (jj_3R_73()) return true;
6680 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6681 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6682 return false;
6683 }
6684
6685 static final private boolean jj_3R_67() {
6686 if (jj_3R_75()) return true;
6687 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6688 return false;
6689 }
6690
6691 static final private boolean jj_3R_49() {
6692 if (jj_scan_token(S_IDENTIFIER)) return true;
6693 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6694 if (jj_scan_token(163)) return true;
6695 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6696 Token xsp;
6697 xsp = jj_scanpos;
6698 if (jj_3R_63()) jj_scanpos = xsp;
6699 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6700 if (jj_scan_token(165)) return true;
6701 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6702 return false;
6703 }
6704
6705 static final private boolean jj_3R_132() {
6706 if (jj_scan_token(172)) return true;
6707 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6708 return false;
6709 }
6710
6711 static final private boolean jj_3R_124() {
6712 if (jj_scan_token(163)) return true;
6713 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6714 if (jj_3R_145()) return true;
6715 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6716 if (jj_scan_token(165)) return true;
6717 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6718 return false;
6719 }
6720
6721 static final private boolean jj_3R_123() {
6722 if (jj_scan_token(S_BIND)) return true;
6723 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6724 return false;
6725 }
6726
6727 static final private boolean jj_3R_113() {
6728 if (jj_scan_token(171)) return true;
6729 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6730 return false;
6731 }
6732
6733 static final private boolean jj_3R_120() {
6734 if (jj_scan_token(K_NEWUID)) return true;
6735 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6736 return false;
6737 }
6738
6739 static final private boolean jj_3R_122() {
6740 if (jj_scan_token(S_CHAR_LITERAL)) return true;
6741 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6742 return false;
6743 }
6744
6745 static final private boolean jj_3_19() {
6746 if (jj_3R_50()) return true;
6747 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6748 return false;
6749 }
6750
6751 static final private boolean jj_3R_119() {
6752 if (jj_scan_token(K_CURSYSDATE)) return true;
6753 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6754 return false;
6755 }
6756
6757 static final private boolean jj_3R_121() {
6758 if (jj_scan_token(S_NUMBER)) return true;
6759 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6760 return false;
6761 }
6762
6763 static final private boolean jj_3_18() {
6764 if (jj_3R_49()) return true;
6765 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6766 return false;
6767 }
6768
6769 static final private boolean jj_3R_118() {
6770 if (jj_scan_token(K_SYSDATE)) return true;
6771 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6772 return false;
6773 }
6774
6775 static final private boolean jj_3R_136() {
6776 if (jj_scan_token(174)) return true;
6777 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6778 return false;
6779 }
6780
6781 static final private boolean jj_3R_117() {
6782 if (jj_3R_128()) return true;
6783 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6784 return false;
6785 }
6786
6787 static final private boolean jj_3R_204() {
6788 if (jj_scan_token(160)) return true;
6789 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6790 if (jj_scan_token(S_IDENTIFIER)) return true;
6791 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6792 return false;
6793 }
6794
6795 static final private boolean jj_3R_116() {
6796 if (jj_3R_50()) return true;
6797 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6798 return false;
6799 }
6800
6801 static final private boolean jj_3R_115() {
6802 if (jj_3R_49()) return true;
6803 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6804 return false;
6805 }
6806
6807 static final private boolean jj_3R_191() {
6808 if (jj_scan_token(S_IDENTIFIER)) return true;
6809 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6810 Token xsp;
6811 xsp = jj_scanpos;
6812 if (jj_3R_204()) jj_scanpos = xsp;
6813 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6814 return false;
6815 }
6816
6817 static final private boolean jj_3R_40() {
6818 if (jj_scan_token(163)) return true;
6819 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6820 return false;
6821 }
6822
6823 static final private boolean jj_3_9() {
6824 Token xsp;
6825 if (jj_3R_40()) return true;
6826 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6827 while (true) {
6828 xsp = jj_scanpos;
6829 if (jj_3R_40()) { jj_scanpos = xsp; break; }
6830 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6831 }
6832 if (jj_scan_token(K_SELECT)) return true;
6833 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6834 return false;
6835 }
6836
6837 static final private boolean jj_3R_114() {
6838 if (jj_scan_token(K_NULL)) return true;
6839 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6840 return false;
6841 }
6842
6843 static final private boolean jj_3R_36() {
6844 if (jj_scan_token(S_IDENTIFIER)) return true;
6845 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6846 return false;
6847 }
6848
6849 static final private boolean jj_3R_98() {
6850 Token xsp;
6851 xsp = jj_scanpos;
6852 if (jj_3R_114()) {
6853 jj_scanpos = xsp;
6854 if (jj_3R_115()) {
6855 jj_scanpos = xsp;
6856 if (jj_3R_116()) {
6857 jj_scanpos = xsp;
6858 if (jj_3R_117()) {
6859 jj_scanpos = xsp;
6860 if (jj_3R_118()) {
6861 jj_scanpos = xsp;
6862 if (jj_3R_119()) {
6863 jj_scanpos = xsp;
6864 if (jj_3R_120()) {
6865 jj_scanpos = xsp;
6866 if (jj_3R_121()) {
6867 jj_scanpos = xsp;
6868 if (jj_3R_122()) {
6869 jj_scanpos = xsp;
6870 if (jj_3R_123()) {
6871 jj_scanpos = xsp;
6872 if (jj_3R_124()) return true;
6873 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6874 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6875 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6876 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6877 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6878 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6879 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6880 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6881 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6882 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6883 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6884 return false;
6885 }
6886
6887 static final private boolean jj_3R_131() {
6888 if (jj_scan_token(171)) return true;
6889 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6890 return false;
6891 }
6892
6893 static final private boolean jj_3R_149() {
6894 if (jj_scan_token(160)) return true;
6895 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6896 if (jj_scan_token(S_IDENTIFIER)) return true;
6897 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6898 return false;
6899 }
6900
6901 static final private boolean jj_3R_146() {
6902 if (jj_scan_token(160)) return true;
6903 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6904 if (jj_scan_token(S_IDENTIFIER)) return true;
6905 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6906 Token xsp;
6907 xsp = jj_scanpos;
6908 if (jj_3R_149()) jj_scanpos = xsp;
6909 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6910 return false;
6911 }
6912
6913 static final private boolean jj_3R_97() {
6914 Token xsp;
6915 xsp = jj_scanpos;
6916 if (jj_3R_112()) {
6917 jj_scanpos = xsp;
6918 if (jj_3R_113()) return true;
6919 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6920 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6921 return false;
6922 }
6923
6924 static final private boolean jj_3R_112() {
6925 if (jj_scan_token(170)) return true;
6926 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6927 return false;
6928 }
6929
6930 static final private boolean jj_3R_128() {
6931 if (jj_scan_token(S_IDENTIFIER)) return true;
6932 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6933 Token xsp;
6934 xsp = jj_scanpos;
6935 if (jj_3R_146()) jj_scanpos = xsp;
6936 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6937 return false;
6938 }
6939
6940 static final private boolean jj_3R_91() {
6941 Token xsp;
6942 xsp = jj_scanpos;
6943 if (jj_3R_97()) jj_scanpos = xsp;
6944 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6945 if (jj_3R_98()) return true;
6946 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6947 return false;
6948 }
6949
6950 static final private boolean jj_3R_66() {
6951 if (jj_scan_token(K_DROP)) return true;
6952 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6953 if (jj_scan_token(K_TABLE)) return true;
6954 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6955 return false;
6956 }
6957
6958 static final private boolean jj_3R_111() {
6959 if (jj_scan_token(163)) return true;
6960 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6961 if (jj_3R_85()) return true;
6962 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6963 if (jj_scan_token(165)) return true;
6964 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6965 return false;
6966 }
6967
6968 static final private boolean jj_3R_134() {
6969 if (jj_scan_token(175)) return true;
6970 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6971 if (jj_3R_91()) return true;
6972 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6973 return false;
6974 }
6975
6976 static final private boolean jj_3R_81() {
6977 if (jj_3R_91()) return true;
6978 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6979 Token xsp;
6980 while (true) {
6981 xsp = jj_scanpos;
6982 if (jj_3R_134()) { jj_scanpos = xsp; break; }
6983 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6984 }
6985 return false;
6986 }
6987
6988 static final private boolean jj_3R_185() {
6989 if (jj_3R_155()) return true;
6990 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6991 return false;
6992 }
6993
6994 static final private boolean jj_3_5() {
6995 if (jj_scan_token(164)) return true;
6996 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6997 if (jj_3R_36()) return true;
6998 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6999 return false;
7000 }
7001
7002 static final private boolean jj_3R_110() {
7003 if (jj_scan_token(S_CHAR_LITERAL)) return true;
7004 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7005 return false;
7006 }
7007
7008 static final private boolean jj_3R_135() {
7009 if (jj_scan_token(173)) return true;
7010 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7011 return false;
7012 }
7013
7014 static final private boolean jj_3R_65() {
7015 if (jj_scan_token(K_CREATE)) return true;
7016 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7017 if (jj_scan_token(K_TABLE)) return true;
7018 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7019 return false;
7020 }
7021
7022 static final private boolean jj_3R_129() {
7023 Token xsp;
7024 xsp = jj_scanpos;
7025 if (jj_3R_135()) {
7026 jj_scanpos = xsp;
7027 if (jj_3R_136()) return true;
7028 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7029 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7030 if (jj_3R_81()) return true;
7031 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7032 return false;
7033 }
7034
7035 static final private boolean jj_3R_70() {
7036 if (jj_3R_81()) return true;
7037 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7038 Token xsp;
7039 while (true) {
7040 xsp = jj_scanpos;
7041 if (jj_3R_129()) { jj_scanpos = xsp; break; }
7042 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7043 }
7044 return false;
7045 }
7046
7047 static final private boolean jj_3R_57() {
7048 if (jj_scan_token(S_QUOTED_IDENTIFIER)) return true;
7049 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7050 return false;
7051 }
7052
7053 static final private boolean jj_3R_109() {
7054 if (jj_scan_token(S_NUMBER)) return true;
7055 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7056 return false;
7057 }
7058
7059 static final private boolean jj_3R_130() {
7060 if (jj_scan_token(170)) return true;
7061 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7062 return false;
7063 }
7064
7065 static final private boolean jj_3R_144() {
7066 if (jj_scan_token(159)) return true;
7067 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7068 return false;
7069 }
7070
7071 static final private boolean jj_3R_125() {
7072 Token xsp;
7073 xsp = jj_scanpos;
7074 if (jj_3R_130()) {
7075 jj_scanpos = xsp;
7076 if (jj_3R_131()) {
7077 jj_scanpos = xsp;
7078 if (jj_3R_132()) return true;
7079 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7080 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7081 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7082 if (jj_3R_70()) return true;
7083 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7084 return false;
7085 }
7086
7087 static final private boolean jj_3R_143() {
7088 if (jj_scan_token(158)) return true;
7089 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7090 return false;
7091 }
7092
7093 static final private boolean jj_3R_142() {
7094 if (jj_scan_token(157)) return true;
7095 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7096 return false;
7097 }
7098
7099 static final private boolean jj_3R_141() {
7100 if (jj_scan_token(156)) return true;
7101 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7102 return false;
7103 }
7104
7105 static final private boolean jj_3R_61() {
7106 if (jj_3R_70()) return true;
7107 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7108 Token xsp;
7109 while (true) {
7110 xsp = jj_scanpos;
7111 if (jj_3R_125()) { jj_scanpos = xsp; break; }
7112 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7113 }
7114 return false;
7115 }
7116
7117 static final private boolean jj_3R_140() {
7118 if (jj_scan_token(155)) return true;
7119 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7120 return false;
7121 }
7122
7123 static final private boolean jj_3R_184() {
7124 if (jj_3R_92()) return true;
7125 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7126 return false;
7127 }
7128
7129 static final private boolean jj_3R_139() {
7130 if (jj_scan_token(154)) return true;
7131 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7132 return false;
7133 }
7134
7135 static final private boolean jj_3R_137() {
7136 Token xsp;
7137 xsp = jj_scanpos;
7138 if (jj_3R_138()) {
7139 jj_scanpos = xsp;
7140 if (jj_3R_139()) {
7141 jj_scanpos = xsp;
7142 if (jj_3R_140()) {
7143 jj_scanpos = xsp;
7144 if (jj_3R_141()) {
7145 jj_scanpos = xsp;
7146 if (jj_3R_142()) {
7147 jj_scanpos = xsp;
7148 if (jj_3R_143()) {
7149 jj_scanpos = xsp;
7150 if (jj_3R_144()) return true;
7151 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7152 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7153 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7154 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7155 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7156 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7157 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7158 return false;
7159 }
7160
7161 static final private boolean jj_3R_138() {
7162 if (jj_scan_token(153)) return true;
7163 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7164 return false;
7165 }
7166
7167 static final private boolean jj_3R_48() {
7168 if (jj_scan_token(163)) return true;
7169 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7170 if (jj_scan_token(K_SELECT)) return true;
7171 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7172 return false;
7173 }
7174
7175 static final private boolean jj_3R_56() {
7176 if (jj_scan_token(S_IDENTIFIER)) return true;
7177 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7178 return false;
7179 }
7180
7181 static final private boolean jj_3R_41() {
7182 Token xsp;
7183 xsp = jj_scanpos;
7184 if (jj_3R_56()) {
7185 jj_scanpos = xsp;
7186 if (jj_3R_57()) return true;
7187 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7188 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7189 return false;
7190 }
7191
7192 static final private boolean jj_3R_62() {
7193 if (jj_scan_token(K_NOT)) return true;
7194 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7195 return false;
7196 }
7197
7198 static final private boolean jj_3R_45() {
7199 Token xsp;
7200 xsp = jj_scanpos;
7201 if (jj_3R_62()) jj_scanpos = xsp;
7202 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7203 if (jj_scan_token(K_LIKE)) return true;
7204 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7205 if (jj_3R_61()) return true;
7206 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7207 return false;
7208 }
7209
7210 static final private boolean jj_3R_108() {
7211 if (jj_scan_token(K_NEWUID)) return true;
7212 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7213 return false;
7214 }
7215
7216 static final private boolean jj_3R_60() {
7217 if (jj_scan_token(K_NOT)) return true;
7218 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7219 return false;
7220 }
7221
7222 static final private boolean jj_3R_47() {
7223 if (jj_scan_token(K_ALL)) return true;
7224 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7225 return false;
7226 }
7227
7228 static final private boolean jj_3R_44() {
7229 Token xsp;
7230 xsp = jj_scanpos;
7231 if (jj_3R_60()) jj_scanpos = xsp;
7232 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7233 if (jj_scan_token(K_BETWEEN)) return true;
7234 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7235 if (jj_3R_61()) return true;
7236 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7237 if (jj_scan_token(K_AND)) return true;
7238 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7239 if (jj_3R_61()) return true;
7240 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7241 return false;
7242 }
7243
7244 static final private boolean jj_3R_207() {
7245 if (jj_scan_token(K_ANY)) return true;
7246 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7247 return false;
7248 }
7249
7250 static final private boolean jj_3R_59() {
7251 if (jj_scan_token(K_NOT)) return true;
7252 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7253 return false;
7254 }
7255
7256 static final private boolean jj_3R_43() {
7257 Token xsp;
7258 xsp = jj_scanpos;
7259 if (jj_3R_59()) jj_scanpos = xsp;
7260 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7261 if (jj_scan_token(K_IN)) return true;
7262 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7263 if (jj_scan_token(163)) return true;
7264 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7265 xsp = jj_scanpos;
7266 if (jj_3R_184()) {
7267 jj_scanpos = xsp;
7268 if (jj_3R_185()) return true;
7269 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7270 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7271 if (jj_scan_token(165)) return true;
7272 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7273 return false;
7274 }
7275
7276 static final private boolean jj_3R_107() {
7277 if (jj_scan_token(K_CURSYSDATE)) return true;
7278 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7279 return false;
7280 }
7281
7282 static final private boolean jj_3_17() {
7283 Token xsp;
7284 xsp = jj_scanpos;
7285 if (jj_3R_46()) {
7286 jj_scanpos = xsp;
7287 if (jj_3R_47()) {
7288 jj_scanpos = xsp;
7289 if (jj_3R_48()) return true;
7290 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7291 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7292 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7293 return false;
7294 }
7295
7296 static final private boolean jj_3R_46() {
7297 if (jj_scan_token(K_ANY)) return true;
7298 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7299 return false;
7300 }
7301
7302 static final private boolean jj_3R_202() {
7303 if (jj_scan_token(K_PRIOR)) return true;
7304 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7305 return false;
7306 }
7307
7308 static final private boolean jj_3R_183() {
7309 Token xsp;
7310 xsp = jj_scanpos;
7311 if (jj_3R_202()) jj_scanpos = xsp;
7312 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7313 if (jj_3R_61()) return true;
7314 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7315 return false;
7316 }
7317
7318 static final private boolean jj_3R_206() {
7319 if (jj_scan_token(K_ALL)) return true;
7320 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7321 return false;
7322 }
7323
7324 static final private boolean jj_3R_201() {
7325 Token xsp;
7326 xsp = jj_scanpos;
7327 if (jj_3R_206()) {
7328 jj_scanpos = xsp;
7329 if (jj_3R_207()) return true;
7330 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7331 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7332 return false;
7333 }
7334
7335 static final private boolean jj_3R_106() {
7336 if (jj_scan_token(K_SYSDATE)) return true;
7337 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7338 return false;
7339 }
7340
7341 static final private boolean jj_3R_182() {
7342 Token xsp;
7343 xsp = jj_scanpos;
7344 if (jj_3R_201()) jj_scanpos = xsp;
7345 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7346 if (jj_scan_token(163)) return true;
7347 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7348 if (jj_3R_155()) return true;
7349 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7350 if (jj_scan_token(165)) return true;
7351 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7352 return false;
7353 }
7354
7355 static final private boolean jj_3R_169() {
7356 if (jj_3R_137()) return true;
7357 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7358 Token xsp;
7359 xsp = jj_scanpos;
7360 if (jj_3R_182()) {
7361 jj_scanpos = xsp;
7362 if (jj_3R_183()) return true;
7363 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7364 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7365 return false;
7366 }
7367
7368 static final private boolean jj_3R_105() {
7369 if (jj_scan_token(S_IDENTIFIER)) return true;
7370 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7371 return false;
7372 }
7373
7374 static final private boolean jj_3R_160() {
7375 if (jj_3R_170()) return true;
7376 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7377 return false;
7378 }
7379
7380 static final private boolean jj_3_16() {
7381 if (jj_3R_45()) return true;
7382 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7383 return false;
7384 }
7385
7386 static final private boolean jj_3R_52() {
7387 if (jj_3R_66()) return true;
7388 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7389 return false;
7390 }
7391
7392 static final private boolean jj_3_15() {
7393 if (jj_3R_44()) return true;
7394 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7395 return false;
7396 }
7397
7398 static final private boolean jj_3_14() {
7399 if (jj_3R_43()) return true;
7400 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7401 return false;
7402 }
7403
7404 static final private boolean jj_3R_99() {
7405 if (jj_scan_token(164)) return true;
7406 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7407 if (jj_3R_61()) return true;
7408 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7409 return false;
7410 }
7411
7412 static final private boolean jj_3R_51() {
7413 if (jj_3R_65()) return true;
7414 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7415 return false;
7416 }
7417
7418 static final private boolean jj_3R_35() {
7419 Token xsp;
7420 xsp = jj_scanpos;
7421 if (jj_3R_51()) {
7422 jj_scanpos = xsp;
7423 if (jj_3R_52()) return true;
7424 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7425 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7426 return false;
7427 }
7428
7429 static final private boolean jj_3R_92() {
7430 if (jj_3R_61()) return true;
7431 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7432 Token xsp;
7433 while (true) {
7434 xsp = jj_scanpos;
7435 if (jj_3R_99()) { jj_scanpos = xsp; break; }
7436 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7437 }
7438 return false;
7439 }
7440
7441 static final private boolean jj_3R_159() {
7442 if (jj_3R_169()) return true;
7443 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7444 return false;
7445 }
7446
7447 static final private boolean jj_3R_157() {
7448 Token xsp;
7449 xsp = jj_scanpos;
7450 if (jj_3R_159()) {
7451 jj_scanpos = xsp;
7452 if (jj_3_14()) {
7453 jj_scanpos = xsp;
7454 if (jj_3_15()) {
7455 jj_scanpos = xsp;
7456 if (jj_3_16()) {
7457 jj_scanpos = xsp;
7458 if (jj_3R_160()) return true;
7459 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7460 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7461 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7462 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7463 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7464 return false;
7465 }
7466
7467 static final private boolean jj_3_4() {
7468 if (jj_3R_35()) return true;
7469 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7470 return false;
7471 }
7472
7473 static final private boolean jj_3R_156() {
7474 if (jj_scan_token(K_PRIOR)) return true;
7475 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7476 return false;
7477 }
7478
7479 static final private boolean jj_3R_54() {
7480 if (jj_scan_token(K_REVERSE)) return true;
7481 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7482 return false;
7483 }
7484
7485 static final private boolean jj_3R_154() {
7486 Token xsp;
7487 xsp = jj_scanpos;
7488 if (jj_3R_156()) jj_scanpos = xsp;
7489 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7490 if (jj_3R_61()) return true;
7491 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7492 xsp = jj_scanpos;
7493 if (jj_3R_157()) jj_scanpos = xsp;
7494 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7495 return false;
7496 }
7497
7498 static final private boolean jj_3R_58() {
7499 if (jj_scan_token(K_NOT)) return true;
7500 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7501 return false;
7502 }
7503
7504 static final private boolean jj_3R_42() {
7505 Token xsp;
7506 xsp = jj_scanpos;
7507 if (jj_3R_58()) jj_scanpos = xsp;
7508 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7509 if (jj_scan_token(K_EXISTS)) return true;
7510 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7511 if (jj_scan_token(163)) return true;
7512 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7513 if (jj_3R_155()) return true;
7514 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7515 if (jj_scan_token(165)) return true;
7516 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7517 return false;
7518 }
7519
7520 static final private boolean jj_3R_103() {
7521 if (jj_scan_token(171)) return true;
7522 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7523 return false;
7524 }
7525
7526 static final private boolean jj_3R_95() {
7527 Token xsp;
7528 xsp = jj_scanpos;
7529 if (jj_3R_102()) {
7530 jj_scanpos = xsp;
7531 if (jj_3R_103()) return true;
7532 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7533 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7534 return false;
7535 }
7536
7537 static final private boolean jj_3R_102() {
7538 if (jj_scan_token(170)) return true;
7539 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7540 return false;
7541 }
7542
7543 static final private boolean jj_3_13() {
7544 if (jj_3R_42()) return true;
7545 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7546 return false;
7547 }
7548
7549 static final private boolean jj_3R_153() {
7550 if (jj_scan_token(K_NOT)) return true;
7551 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7552 return false;
7553 }
7554
7555 static final private boolean jj_3R_152() {
7556 Token xsp;
7557 xsp = jj_scanpos;
7558 if (jj_3R_153()) jj_scanpos = xsp;
7559 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7560 if (jj_3R_154()) return true;
7561 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7562 return false;
7563 }
7564
7565 static final private boolean jj_3R_104() {
7566 if (jj_scan_token(K_NULL)) return true;
7567 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7568 return false;
7569 }
7570
7571 static final private boolean jj_3R_96() {
7572 Token xsp;
7573 xsp = jj_scanpos;
7574 if (jj_3R_104()) {
7575 jj_scanpos = xsp;
7576 if (jj_3R_105()) {
7577 jj_scanpos = xsp;
7578 if (jj_3R_106()) {
7579 jj_scanpos = xsp;
7580 if (jj_3R_107()) {
7581 jj_scanpos = xsp;
7582 if (jj_3R_108()) {
7583 jj_scanpos = xsp;
7584 if (jj_3R_109()) {
7585 jj_scanpos = xsp;
7586 if (jj_3R_110()) {
7587 jj_scanpos = xsp;
7588 if (jj_3R_111()) return true;
7589 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7590 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7591 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7592 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7593 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7594 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7595 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7596 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7597 return false;
7598 }
7599
7600 static final private boolean jj_3R_150() {
7601 Token xsp;
7602 xsp = jj_scanpos;
7603 if (jj_3_13()) {
7604 jj_scanpos = xsp;
7605 if (jj_3R_152()) return true;
7606 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7607 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7608 return false;
7609 }
7610
7611 static final private boolean jj_3R_151() {
7612 if (jj_scan_token(K_AND)) return true;
7613 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7614 if (jj_3R_150()) return true;
7615 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7616 return false;
7617 }
7618
7619 static final private boolean jj_3R_198() {
7620 if (jj_scan_token(K_MINUS)) return true;
7621 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7622 return false;
7623 }
7624
7625 static final private boolean jj_3R_147() {
7626 if (jj_3R_150()) return true;
7627 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7628 Token xsp;
7629 while (true) {
7630 xsp = jj_scanpos;
7631 if (jj_3R_151()) { jj_scanpos = xsp; break; }
7632 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7633 }
7634 return false;
7635 }
7636
7637 static final private boolean jj_3_8() {
7638 if (jj_3R_39()) return true;
7639 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7640 return false;
7641 }
7642
7643 static final private boolean jj_3R_39() {
7644 if (jj_scan_token(K_FOR)) return true;
7645 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7646 if (jj_scan_token(S_IDENTIFIER)) return true;
7647 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7648 if (jj_scan_token(K_IN)) return true;
7649 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7650 Token xsp;
7651 xsp = jj_scanpos;
7652 if (jj_3R_54()) jj_scanpos = xsp;
7653 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7654 if (jj_3R_55()) return true;
7655 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7656 if (jj_scan_token(169)) return true;
7657 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7658 return false;
7659 }
7660
7661 static final private boolean jj_3R_148() {
7662 if (jj_scan_token(K_OR)) return true;
7663 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7664 if (jj_3R_147()) return true;
7665 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7666 return false;
7667 }
7668
7669 static final private boolean jj_3R_145() {
7670 if (jj_3R_147()) return true;
7671 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7672 Token xsp;
7673 while (true) {
7674 xsp = jj_scanpos;
7675 if (jj_3R_148()) { jj_scanpos = xsp; break; }
7676 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7677 }
7678 return false;
7679 }
7680
7681 static final private boolean jj_3R_87() {
7682 Token xsp;
7683 xsp = jj_scanpos;
7684 if (jj_3R_95()) jj_scanpos = xsp;
7685 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7686 if (jj_3R_96()) return true;
7687 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7688 return false;
7689 }
7690
7691 static final private boolean jj_3R_88() {
7692 if (jj_scan_token(175)) return true;
7693 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7694 if (jj_3R_87()) return true;
7695 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7696 return false;
7697 }
7698
7699 static final private boolean jj_3R_197() {
7700 if (jj_scan_token(K_INTERSECT)) return true;
7701 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7702 return false;
7703 }
7704
7705 static final private boolean jj_3R_34() {
7706 if (jj_scan_token(K_GET)) return true;
7707 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7708 if (jj_scan_token(K_VALUE_USE)) return true;
7709 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7710 return false;
7711 }
7712
7713 static final private boolean jj_3_12() {
7714 if (jj_scan_token(163)) return true;
7715 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7716 return false;
7717 }
7718
7719 static final private boolean jj_3R_205() {
7720 if (jj_scan_token(K_ALL)) return true;
7721 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7722 return false;
7723 }
7724
7725 static final private boolean jj_3R_200() {
7726 if (jj_3R_158()) return true;
7727 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7728 return false;
7729 }
7730
7731 static final private boolean jj_3R_76() {
7732 if (jj_3R_87()) return true;
7733 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7734 Token xsp;
7735 while (true) {
7736 xsp = jj_scanpos;
7737 if (jj_3R_88()) { jj_scanpos = xsp; break; }
7738 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7739 }
7740 return false;
7741 }
7742
7743 static final private boolean jj_3R_199() {
7744 if (jj_scan_token(163)) return true;
7745 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7746 if (jj_3R_158()) return true;
7747 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7748 if (jj_scan_token(165)) return true;
7749 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7750 return false;
7751 }
7752
7753 static final private boolean jj_3R_33() {
7754 if (jj_scan_token(K_GET)) return true;
7755 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7756 if (jj_scan_token(K_SLOT)) return true;
7757 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7758 return false;
7759 }
7760
7761 static final private boolean jj_3R_196() {
7762 if (jj_scan_token(K_UNION)) return true;
7763 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7764 Token xsp;
7765 xsp = jj_scanpos;
7766 if (jj_3R_205()) jj_scanpos = xsp;
7767 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7768 return false;
7769 }
7770
7771 static final private boolean jj_3R_181() {
7772 Token xsp;
7773 xsp = jj_scanpos;
7774 if (jj_3R_196()) {
7775 jj_scanpos = xsp;
7776 if (jj_3R_197()) {
7777 jj_scanpos = xsp;
7778 if (jj_3R_198()) return true;
7779 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7780 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7781 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7782 xsp = jj_scanpos;
7783 if (jj_3R_199()) {
7784 jj_scanpos = xsp;
7785 if (jj_3R_200()) return true;
7786 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7787 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7788 return false;
7789 }
7790
7791 static final private boolean jj_3R_90() {
7792 if (jj_scan_token(174)) return true;
7793 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7794 return false;
7795 }
7796
7797 static final private boolean jj_3R_89() {
7798 if (jj_scan_token(173)) return true;
7799 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7800 return false;
7801 }
7802
7803 static final private boolean jj_3R_77() {
7804 Token xsp;
7805 xsp = jj_scanpos;
7806 if (jj_3R_89()) {
7807 jj_scanpos = xsp;
7808 if (jj_3R_90()) return true;
7809 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7810 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7811 if (jj_3R_76()) return true;
7812 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7813 return false;
7814 }
7815
7816 static final private boolean jj_3R_195() {
7817 if (jj_scan_token(K_HAVING)) return true;
7818 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7819 if (jj_3R_145()) return true;
7820 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7821 return false;
7822 }
7823
7824 static final private boolean jj_3R_180() {
7825 if (jj_scan_token(K_GROUP)) return true;
7826 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7827 if (jj_scan_token(K_BY)) return true;
7828 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7829 if (jj_3R_92()) return true;
7830 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7831 Token xsp;
7832 xsp = jj_scanpos;
7833 if (jj_3R_195()) jj_scanpos = xsp;
7834 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7835 return false;
7836 }
7837
7838 static final private boolean jj_3R_194() {
7839 if (jj_scan_token(K_START)) return true;
7840 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7841 if (jj_scan_token(K_WITH)) return true;
7842 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7843 if (jj_3R_145()) return true;
7844 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7845 return false;
7846 }
7847
7848 static final private boolean jj_3R_32() {
7849 if (jj_scan_token(K_GET)) return true;
7850 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7851 if (jj_scan_token(K_ESCROW)) return true;
7852 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7853 return false;
7854 }
7855
7856 static final private boolean jj_3R_193() {
7857 if (jj_scan_token(K_START)) return true;
7858 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7859 if (jj_scan_token(K_WITH)) return true;
7860 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7861 if (jj_3R_145()) return true;
7862 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7863 return false;
7864 }
7865
7866 static final private boolean jj_3R_177() {
7867 if (jj_scan_token(164)) return true;
7868 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7869 if (jj_3R_176()) return true;
7870 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7871 return false;
7872 }
7873
7874 static final private boolean jj_3R_179() {
7875 Token xsp;
7876 xsp = jj_scanpos;
7877 if (jj_3R_193()) jj_scanpos = xsp;
7878 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7879 if (jj_scan_token(K_CONNECT)) return true;
7880 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7881 if (jj_scan_token(K_BY)) return true;
7882 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7883 if (jj_3R_145()) return true;
7884 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7885 xsp = jj_scanpos;
7886 if (jj_3R_194()) jj_scanpos = xsp;
7887 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7888 return false;
7889 }
7890
7891 static final private boolean jj_3_3() {
7892 if (jj_3R_34()) return true;
7893 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7894 return false;
7895 }
7896
7897 static final private boolean jj_3_2() {
7898 if (jj_3R_33()) return true;
7899 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7900 return false;
7901 }
7902
7903 static final private boolean jj_3_1() {
7904 if (jj_3R_32()) return true;
7905 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7906 return false;
7907 }
7908
7909 static final private boolean jj_3R_68() {
7910 if (jj_3R_76()) return true;
7911 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7912 Token xsp;
7913 while (true) {
7914 xsp = jj_scanpos;
7915 if (jj_3R_77()) { jj_scanpos = xsp; break; }
7916 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7917 }
7918 return false;
7919 }
7920
7921 static final private boolean jj_3R_178() {
7922 if (jj_scan_token(K_WHERE)) return true;
7923 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7924 if (jj_3R_145()) return true;
7925 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7926 return false;
7927 }
7928
7929 static final private boolean jj_3R_192() {
7930 if (jj_scan_token(S_IDENTIFIER)) return true;
7931 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7932 return false;
7933 }
7934
7935 static final private boolean jj_3R_80() {
7936 if (jj_scan_token(172)) return true;
7937 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7938 return false;
7939 }
7940
7941 static final private boolean jj_3R_79() {
7942 if (jj_scan_token(171)) return true;
7943 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7944 return false;
7945 }
7946
7947 static final private boolean jj_3R_78() {
7948 if (jj_scan_token(170)) return true;
7949 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7950 return false;
7951 }
7952
7953 static final private boolean jj_3R_69() {
7954 Token xsp;
7955 xsp = jj_scanpos;
7956 if (jj_3R_78()) {
7957 jj_scanpos = xsp;
7958 if (jj_3R_79()) {
7959 jj_scanpos = xsp;
7960 if (jj_3R_80()) return true;
7961 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7962 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7963 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7964 if (jj_3R_68()) return true;
7965 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7966 return false;
7967 }
7968
7969 static final private boolean jj_3R_176() {
7970 if (jj_3R_191()) return true;
7971 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7972 Token xsp;
7973 xsp = jj_scanpos;
7974 if (jj_3R_192()) jj_scanpos = xsp;
7975 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7976 return false;
7977 }
7978
7979 static final private boolean jj_3R_190() {
7980 if (jj_scan_token(164)) return true;
7981 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7982 if (jj_3R_189()) return true;
7983 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7984 return false;
7985 }
7986
7987 static final private boolean jj_3R_164() {
7988 if (jj_scan_token(K_FROM)) return true;
7989 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7990 if (jj_3R_176()) return true;
7991 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7992 Token xsp;
7993 while (true) {
7994 xsp = jj_scanpos;
7995 if (jj_3R_177()) { jj_scanpos = xsp; break; }
7996 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7997 }
7998 return false;
7999 }
8000
8001 static final private boolean jj_3R_55() {
8002 if (jj_3R_68()) return true;
8003 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8004 Token xsp;
8005 while (true) {
8006 xsp = jj_scanpos;
8007 if (jj_3R_69()) { jj_scanpos = xsp; break; }
8008 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8009 }
8010 return false;
8011 }
8012
8013 static final private boolean jj_3R_53() {
8014 if (jj_scan_token(163)) return true;
8015 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8016 if (jj_3R_67()) return true;
8017 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8018 if (jj_scan_token(165)) return true;
8019 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8020 return false;
8021 }
8022
8023 static final private boolean jj_3R_189() {
8024 if (jj_scan_token(S_IDENTIFIER)) return true;
8025 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8026 return false;
8027 }
8028
8029 static final private boolean jj_3R_186() {
8030 if (jj_scan_token(K_NOT)) return true;
8031 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8032 return false;
8033 }
8034
8035 static final private boolean jj_3R_38() {
8036 if (jj_scan_token(S_IDENTIFIER)) return true;
8037 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8038 Token xsp;
8039 xsp = jj_scanpos;
8040 if (jj_3R_53()) jj_scanpos = xsp;
8041 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8042 if (jj_scan_token(161)) return true;
8043 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8044 return false;
8045 }
8046
8047 static final private boolean jj_3R_170() {
8048 if (jj_scan_token(K_IS)) return true;
8049 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8050 Token xsp;
8051 xsp = jj_scanpos;
8052 if (jj_3R_186()) jj_scanpos = xsp;
8053 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8054 if (jj_scan_token(K_NULL)) return true;
8055 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8056 return false;
8057 }
8058
8059 static final private boolean jj_3R_188() {
8060 if (jj_scan_token(164)) return true;
8061 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8062 if (jj_3R_187()) return true;
8063 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8064 return false;
8065 }
8066
8067 static final private boolean jj_3R_175() {
8068 if (jj_scan_token(K_INTO)) return true;
8069 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8070 if (jj_3R_189()) return true;
8071 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8072 Token xsp;
8073 while (true) {
8074 xsp = jj_scanpos;
8075 if (jj_3R_190()) { jj_scanpos = xsp; break; }
8076 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8077 }
8078 return false;
8079 }
8080
8081 static final private boolean jj_3R_208() {
8082 if (jj_scan_token(S_IDENTIFIER)) return true;
8083 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8084 return false;
8085 }
8086
8087 static final private boolean jj_3R_203() {
8088 if (jj_3R_61()) return true;
8089 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8090 Token xsp;
8091 xsp = jj_scanpos;
8092 if (jj_3R_208()) jj_scanpos = xsp;
8093 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8094 return false;
8095 }
8096
8097 static final private boolean jj_3_11() {
8098 if (jj_3R_41()) return true;
8099 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8100 if (jj_scan_token(160)) return true;
8101 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8102 if (jj_3R_41()) return true;
8103 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8104 if (jj_scan_token(176)) return true;
8105 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8106 return false;
8107 }
8108
8109 static final private boolean jj_3R_187() {
8110 Token xsp;
8111 xsp = jj_scanpos;
8112 if (jj_3_10()) {
8113 jj_scanpos = xsp;
8114 if (jj_3_11()) {
8115 jj_scanpos = xsp;
8116 if (jj_3R_203()) return true;
8117 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8118 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8119 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8120 return false;
8121 }
8122
8123 static final private boolean jj_3_10() {
8124 if (jj_3R_41()) return true;
8125 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8126 if (jj_scan_token(176)) return true;
8127 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8128 return false;
8129 }
8130
8131 static final private boolean jj_3R_86() {
8132 if (jj_scan_token(164)) return true;
8133 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8134 if (jj_3R_85()) return true;
8135 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8136 return false;
8137 }
8138
8139 static final private boolean jj_3R_75() {
8140 if (jj_3R_85()) return true;
8141 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8142 Token xsp;
8143 while (true) {
8144 xsp = jj_scanpos;
8145 if (jj_3R_86()) { jj_scanpos = xsp; break; }
8146 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8147 }
8148 return false;
8149 }
8150
8151 static final private boolean jj_3R_174() {
8152 if (jj_3R_187()) return true;
8153 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8154 Token xsp;
8155 while (true) {
8156 xsp = jj_scanpos;
8157 if (jj_3R_188()) { jj_scanpos = xsp; break; }
8158 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8159 }
8160 return false;
8161 }
8162
8163 static final private boolean jj_3R_173() {
8164 if (jj_scan_token(173)) return true;
8165 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8166 return false;
8167 }
8168
8169 static final private boolean jj_3R_162() {
8170 Token xsp;
8171 xsp = jj_scanpos;
8172 if (jj_3R_173()) {
8173 jj_scanpos = xsp;
8174 if (jj_3R_174()) return true;
8175 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8176 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8177 return false;
8178 }
8179
8180 static final private boolean jj_3R_133() {
8181 if (jj_3R_137()) return true;
8182 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8183 if (jj_3R_55()) return true;
8184 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8185 return false;
8186 }
8187
8188 static final private boolean jj_3_7() {
8189 if (jj_3R_38()) return true;
8190 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8191 return false;
8192 }
8193
8194 static final private boolean jj_3R_74() {
8195 if (jj_scan_token(160)) return true;
8196 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8197 if (jj_3R_41()) return true;
8198 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8199 return false;
8200 }
8201
8202 static final private boolean jj_3R_127() {
8203 if (jj_3R_55()) return true;
8204 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8205 Token xsp;
8206 xsp = jj_scanpos;
8207 if (jj_3R_133()) jj_scanpos = xsp;
8208 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8209 return false;
8210 }
8211
8212 static final private boolean jj_3R_126() {
8213 if (jj_scan_token(K_NOT)) return true;
8214 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8215 return false;
8216 }
8217
8218 static final private boolean jj_3R_100() {
8219 Token xsp;
8220 xsp = jj_scanpos;
8221 if (jj_3R_126()) jj_scanpos = xsp;
8222 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8223 if (jj_3R_127()) return true;
8224 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8225 return false;
8226 }
8227
8228 static final private boolean jj_3R_73() {
8229 if (jj_scan_token(173)) return true;
8230 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8231 return false;
8232 }
8233
8234 static final private boolean jj_3R_72() {
8235 if (jj_3R_84()) return true;
8236 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8237 return false;
8238 }
8239
8240 static final private boolean jj_3R_64() {
8241 if (jj_scan_token(160)) return true;
8242 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8243 if (jj_3R_41()) return true;
8244 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8245 Token xsp;
8246 xsp = jj_scanpos;
8247 if (jj_3R_74()) jj_scanpos = xsp;
8248 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8249 return false;
8250 }
8251
8252 static final private boolean jj_3R_168() {
8253 if (jj_3R_181()) return true;
8254 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8255 return false;
8256 }
8257
8258 static final private boolean jj_3R_37() {
8259 if (jj_scan_token(K_ON)) return true;
8260 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8261 if (jj_scan_token(K_COMMIT)) return true;
8262 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8263 return false;
8264 }
8265
8266 static final private boolean jj_3R_83() {
8267 if (jj_scan_token(K_ALL)) return true;
8268 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8269 return false;
8270 }
8271
8272 static final private boolean jj_3R_172() {
8273 if (jj_scan_token(K_DISTINCT)) return true;
8274 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8275 return false;
8276 }
8277
8278 static final private boolean jj_3R_167() {
8279 if (jj_3R_180()) return true;
8280 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8281 return false;
8282 }
8283
8284 static final private boolean jj_3R_101() {
8285 if (jj_scan_token(K_AND)) return true;
8286 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8287 if (jj_3R_100()) return true;
8288 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8289 return false;
8290 }
8291
8292 static final private boolean jj_3R_166() {
8293 if (jj_3R_179()) return true;
8294 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8295 return false;
8296 }
8297
8298 static final private boolean jj_3R_163() {
8299 if (jj_3R_175()) return true;
8300 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8301 return false;
8302 }
8303
8304 static final private boolean jj_3R_165() {
8305 if (jj_3R_178()) return true;
8306 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8307 return false;
8308 }
8309
8310 static final private boolean jj_3R_171() {
8311 if (jj_scan_token(K_ALL)) return true;
8312 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8313 return false;
8314 }
8315
8316 static final private boolean jj_3R_161() {
8317 Token xsp;
8318 xsp = jj_scanpos;
8319 if (jj_3R_171()) {
8320 jj_scanpos = xsp;
8321 if (jj_3R_172()) return true;
8322 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8323 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8324 return false;
8325 }
8326
8327 static final private boolean jj_3R_93() {
8328 if (jj_3R_100()) return true;
8329 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8330 Token xsp;
8331 while (true) {
8332 xsp = jj_scanpos;
8333 if (jj_3R_101()) { jj_scanpos = xsp; break; }
8334 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8335 }
8336 return false;
8337 }
8338
8339 static final private boolean jj_3R_155() {
8340 if (jj_3R_158()) return true;
8341 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8342 return false;
8343 }
8344
8345 static final private boolean jj_3R_50() {
8346 if (jj_3R_41()) return true;
8347 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8348 Token xsp;
8349 xsp = jj_scanpos;
8350 if (jj_3R_64()) jj_scanpos = xsp;
8351 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8352 if (jj_scan_token(163)) return true;
8353 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8354 if (jj_scan_token(170)) return true;
8355 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8356 if (jj_scan_token(165)) return true;
8357 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8358 return false;
8359 }
8360
8361 static final private boolean jj_3R_158() {
8362 if (jj_scan_token(K_SELECT)) return true;
8363 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8364 Token xsp;
8365 xsp = jj_scanpos;
8366 if (jj_3R_161()) jj_scanpos = xsp;
8367 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8368 if (jj_3R_162()) return true;
8369 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8370 xsp = jj_scanpos;
8371 if (jj_3R_163()) jj_scanpos = xsp;
8372 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8373 if (jj_3R_164()) return true;
8374 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8375 xsp = jj_scanpos;
8376 if (jj_3R_165()) jj_scanpos = xsp;
8377 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8378 xsp = jj_scanpos;
8379 if (jj_3R_166()) jj_scanpos = xsp;
8380 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8381 xsp = jj_scanpos;
8382 if (jj_3R_167()) jj_scanpos = xsp;
8383 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8384 xsp = jj_scanpos;
8385 if (jj_3R_168()) jj_scanpos = xsp;
8386 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8387 return false;
8388 }
8389
8390 static final private boolean jj_3R_94() {
8391 if (jj_scan_token(K_OR)) return true;
8392 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8393 if (jj_3R_93()) return true;
8394 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8395 return false;
8396 }
8397
8398 static private boolean jj_initialized_once = false;
8399 static public MobisnapSQLTokenManager token_source;
8400 static JavaCharStream jj_input_stream;
8401 static public Token token, jj_nt;
8402 static private int jj_ntk;
8403 static private Token jj_scanpos, jj_lastpos;
8404 static private int jj_la;
8405 static public boolean lookingAhead = false;
8406 static private boolean jj_semLA;
8407 static private int jj_gen;
8408 static final private int[] jj_la1 = new int[185];
8409 static final private int[] jj_la1_0 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x42816000,0x0,0x0,0x0,0x0,0x0,0x0,0x2010000,0x0,0x0,0x42016000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x4000000,0x4000000,0x4000000,0x0,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x200000,0x0,0x0,0x20,0x20,0x0,0x0,0x400000,0x0,0x0,0x20,0x20,0x0,0x0,0x400000,0x0,0x0,0x0,0x20000000,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x400,0x400,0x0,0x400,0x400,0x0,0x0,0x40,0x0,0x20000000,0x0,0x0,0x0,0x0,0x1000,0x0,0x120,0x120,0x0,0x20000000,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20,0x20,0x20000000,0x20000020,0x0,0x0,};
8410 static final private int[] jj_la1_1 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x2,0x2,0x0,0x2,0x2,0x100000,0x0,0x0,0x100000,0x1000000,0x20080,0x20080,0x0,0x20080,0x20080,0x20080,0x20080,0x0,0x20080,0x20080,0x0,0x40,0x0,0x40,0x0,0x20080,0x20080,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x90000004,0x0,0x0,0x0,0x90000004,0x1,0x0,0x0,0x0,0x200,0x100,0x0,0x200000,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x8000,0x0,0x10000,0x0,0x0,0x10000,0x0,0x0,0x0,0x400000,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000004,0x0,0x200000,0x10,0x10,0x0,0x0,0x0,0x4000000,0x0,0x10,0x10,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x8,0x8,0x0,0x8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x10,0x0,0x0,};
8411 static final private int[] jj_la1_2 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x42002,0x8000,0x0,0x0,0x8000,0x0,0x0,0x42002,0x0,0x0,0x42002,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x100000,0x0,0x20000,0x0,0x800000,0x2000000,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x8002c000,0x0,0x0,0x8002c000,0x0,0x0,0x0,0x0,0x0,0x8002c000,0x0,0x800000,0x0,0x8000,0x0,0x0,0x8000,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x24000,0x0,0x1000000,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x404,0x0,0x0,0x8,0x0,0x0,0x0,0x404,0x0,0x24000,0x0,0x24000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x404,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x8000,0x8002c000,0x8000,0x80000000,0x0,0x20,0x80a0,0x0,0x0,0x0,0x80000000,0x80024000,0x8000,0x24000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x4000,0x0,0x0,0x24000,0x24000,0x0,0x0,};
8412 static final private int[] jj_la1_3 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x0,0x0,0x80004400,0x0,0x0,0x0,0x80004400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x8000000,0x0,0x0,0x8,0x10000,0x80000800,0x80000800,0x10800,0x0,0x200000,0x0,0x0,0x200000,0x0,0x0,0x4000,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x80004400,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x20000000,0x0,0x0,0x0,0x0,0x800000,0x0,0x20000000,0x0,0x200000,0x0,0x200000,0x0,0x0,0x0,0x800000,0x800000,0x0,0x0,0x20000000,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x204000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x0,0x200000,0x200000,0x0,0x0,};
8413 static final private int[] jj_la1_4 = {0x1080000,0xfe000000,0x0,0x0,0x0,0x0,0x0,0x80000,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x80000,0x80,0x0,0x80000,0x80000,0x0,0x0,0x80000,0x80,0x0,0x0,0x80000,0x200,0x80000,0x0,0x0,0x0,0x0,0x80000,0x80000,0x882000,0x800,0x0,0x480000,0x0,0x480000,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x1000,0x1,0x0,0x0,0x0,0x0,0x80000,0x1c82000,0x100,0x0,0x1c82000,0x0,0x0,0x10,0x0,0x80000,0x1c82000,0x100,0x0,0x0,0x0,0xfe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x882000,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x1c82000,0x80000,0x1c82000,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c82000,0x0,0x0,0xfe000000,0x0,0xfe000000,0x0,0x0,0x0,0x0,0x1c82000,0x0,0x1c82000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc82000,0x0,0x0,0x1c82000,0x1c82000,0x0,0x0,};
8414 static final private int[] jj_la1_5 = {0x0,0x0,0x1,0x1,0x1,0x1,0x1,0x0,0x0,0x0,0x4,0x4,0x0,0x4,0x4,0x0,0x10,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x40,0x40,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x8,0x0,0xc08,0x0,0x0,0x0,0x10,0x0,0x10,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc08,0x0,0x10,0xc08,0x10,0x8,0x0,0x0,0x0,0xc08,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x1c00,0x1c00,0x6000,0x6000,0x8000,0xc00,0xc00,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x2c08,0x0,0xc08,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x0,0xc08,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0xc08,0x0,0xc08,0x0,0x0,0x1c00,0x1c00,0x6000,0x6000,0x8000,0xc00,0xc00,0x0,0x8,0x0,0x0,0x2c08,0x2c08,0x1,0x1,};
8415 static final private JJCalls[] jj_2_rtns = new JJCalls[19];
8416 static private boolean jj_rescan = false;
8417 static private int jj_gc = 0;
8418
8419 public MobisnapSQL(java.io.InputStream stream) {
8420 if (jj_initialized_once) {
8421 System.out.println("ERROR: Second call to constructor of static parser. You must");
8422 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
8423 System.out.println(" during parser generation.");
8424 throw new Error();
8425 }
8426 jj_initialized_once = true;
8427 jj_input_stream = new JavaCharStream(stream, 1, 1);
8428 token_source = new MobisnapSQLTokenManager(jj_input_stream);
8429 token = new Token();
8430 jj_ntk = -1;
8431 jj_gen = 0;
8432 for (int i = 0; i < 185; i++) jj_la1[i] = -1;
8433 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
8434 }
8435
8436 static public void ReInit(java.io.InputStream stream) {
8437 jj_input_stream.ReInit(stream, 1, 1);
8438 token_source.ReInit(jj_input_stream);
8439 token = new Token();
8440 jj_ntk = -1;
8441 jjtree.reset();
8442 jj_gen = 0;
8443 for (int i = 0; i < 185; i++) jj_la1[i] = -1;
8444 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
8445 }
8446
8447 public MobisnapSQL(java.io.Reader stream) {
8448 if (jj_initialized_once) {
8449 System.out.println("ERROR: Second call to constructor of static parser. You must");
8450 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
8451 System.out.println(" during parser generation.");
8452 throw new Error();
8453 }
8454 jj_initialized_once = true;
8455 jj_input_stream = new JavaCharStream(stream, 1, 1);
8456 token_source = new MobisnapSQLTokenManager(jj_input_stream);
8457 token = new Token();
8458 jj_ntk = -1;
8459 jj_gen = 0;
8460 for (int i = 0; i < 185; i++) jj_la1[i] = -1;
8461 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
8462 }
8463
8464 static public void ReInit(java.io.Reader stream) {
8465 jj_input_stream.ReInit(stream, 1, 1);
8466 token_source.ReInit(jj_input_stream);
8467 token = new Token();
8468 jj_ntk = -1;
8469 jjtree.reset();
8470 jj_gen = 0;
8471 for (int i = 0; i < 185; i++) jj_la1[i] = -1;
8472 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
8473 }
8474
8475 public MobisnapSQL(MobisnapSQLTokenManager tm) {
8476 if (jj_initialized_once) {
8477 System.out.println("ERROR: Second call to constructor of static parser. You must");
8478 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
8479 System.out.println(" during parser generation.");
8480 throw new Error();
8481 }
8482 jj_initialized_once = true;
8483 token_source = tm;
8484 token = new Token();
8485 jj_ntk = -1;
8486 jj_gen = 0;
8487 for (int i = 0; i < 185; i++) jj_la1[i] = -1;
8488 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
8489 }
8490
8491 public void ReInit(MobisnapSQLTokenManager tm) {
8492 token_source = tm;
8493 token = new Token();
8494 jj_ntk = -1;
8495 jjtree.reset();
8496 jj_gen = 0;
8497 for (int i = 0; i < 185; i++) jj_la1[i] = -1;
8498 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
8499 }
8500
8501 static final private Token jj_consume_token(int kind) throws ParseException {
8502 Token oldToken;
8503 if ((oldToken = token).next != null) token = token.next;
8504 else token = token.next = token_source.getNextToken();
8505 jj_ntk = -1;
8506 if (token.kind == kind) {
8507 jj_gen++;
8508 if (++jj_gc > 100) {
8509 jj_gc = 0;
8510 for (int i = 0; i < jj_2_rtns.length; i++) {
8511 JJCalls c = jj_2_rtns[i];
8512 while (c != null) {
8513 if (c.gen < jj_gen) c.first = null;
8514 c = c.next;
8515 }
8516 }
8517 }
8518 return token;
8519 }
8520 token = oldToken;
8521 jj_kind = kind;
8522 throw generateParseException();
8523 }
8524
8525 static final private boolean jj_scan_token(int kind) {
8526 if (jj_scanpos == jj_lastpos) {
8527 jj_la--;
8528 if (jj_scanpos.next == null) {
8529 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
8530 } else {
8531 jj_lastpos = jj_scanpos = jj_scanpos.next;
8532 }
8533 } else {
8534 jj_scanpos = jj_scanpos.next;
8535 }
8536 if (jj_rescan) {
8537 int i = 0; Token tok = token;
8538 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
8539 if (tok != null) jj_add_error_token(kind, i);
8540 }
8541 return (jj_scanpos.kind != kind);
8542 }
8543
8544 static final public Token getNextToken() {
8545 if (token.next != null) token = token.next;
8546 else token = token.next = token_source.getNextToken();
8547 jj_ntk = -1;
8548 jj_gen++;
8549 return token;
8550 }
8551
8552 static final public Token getToken(int index) {
8553 Token t = lookingAhead ? jj_scanpos : token;
8554 for (int i = 0; i < index; i++) {
8555 if (t.next != null) t = t.next;
8556 else t = t.next = token_source.getNextToken();
8557 }
8558 return t;
8559 }
8560
8561 static final private int jj_ntk() {
8562 if ((jj_nt=token.next) == null)
8563 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
8564 else
8565 return (jj_ntk = jj_nt.kind);
8566 }
8567
8568 static private java.util.Vector jj_expentries = new java.util.Vector();
8569 static private int[] jj_expentry;
8570 static private int jj_kind = -1;
8571 static private int[] jj_lasttokens = new int[100];
8572 static private int jj_endpos;
8573
8574 static private void jj_add_error_token(int kind, int pos) {
8575 if (pos >= 100) return;
8576 if (pos == jj_endpos + 1) {
8577 jj_lasttokens[jj_endpos++] = kind;
8578 } else if (jj_endpos != 0) {
8579 jj_expentry = new int[jj_endpos];
8580 for (int i = 0; i < jj_endpos; i++) {
8581 jj_expentry[i] = jj_lasttokens[i];
8582 }
8583 boolean exists = false;
8584 for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
8585 int[] oldentry = (int[])(enum.nextElement());
8586 if (oldentry.length == jj_expentry.length) {
8587 exists = true;
8588 for (int i = 0; i < jj_expentry.length; i++) {
8589 if (oldentry[i] != jj_expentry[i]) {
8590 exists = false;
8591 break;
8592 }
8593 }
8594 if (exists) break;
8595 }
8596 }
8597 if (!exists) jj_expentries.addElement(jj_expentry);
8598 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
8599 }
8600 }
8601
8602 static final public ParseException generateParseException() {
8603 jj_expentries.removeAllElements();
8604 boolean[] la1tokens = new boolean[177];
8605 for (int i = 0; i < 177; i++) {
8606 la1tokens[i] = false;
8607 }
8608 if (jj_kind >= 0) {
8609 la1tokens[jj_kind] = true;
8610 jj_kind = -1;
8611 }
8612 for (int i = 0; i < 185; i++) {
8613 if (jj_la1[i] == jj_gen) {
8614 for (int j = 0; j < 32; j++) {
8615 if ((jj_la1_0[i] & (1<<j)) != 0) {
8616 la1tokens[j] = true;
8617 }
8618 if ((jj_la1_1[i] & (1<<j)) != 0) {
8619 la1tokens[32+j] = true;
8620 }
8621 if ((jj_la1_2[i] & (1<<j)) != 0) {
8622 la1tokens[64+j] = true;
8623 }
8624 if ((jj_la1_3[i] & (1<<j)) != 0) {
8625 la1tokens[96+j] = true;
8626 }
8627 if ((jj_la1_4[i] & (1<<j)) != 0) {
8628 la1tokens[128+j] = true;
8629 }
8630 if ((jj_la1_5[i] & (1<<j)) != 0) {
8631 la1tokens[160+j] = true;
8632 }
8633 }
8634 }
8635 }
8636 for (int i = 0; i < 177; i++) {
8637 if (la1tokens[i]) {
8638 jj_expentry = new int[1];
8639 jj_expentry[0] = i;
8640 jj_expentries.addElement(jj_expentry);
8641 }
8642 }
8643 jj_endpos = 0;
8644 jj_rescan_token();
8645 jj_add_error_token(0, 0);
8646 int[][] exptokseq = new int[jj_expentries.size()][];
8647 for (int i = 0; i < jj_expentries.size(); i++) {
8648 exptokseq[i] = (int[])jj_expentries.elementAt(i);
8649 }
8650 return new ParseException(token, exptokseq, tokenImage);
8651 }
8652
8653 static final public void enable_tracing() {
8654 }
8655
8656 static final public void disable_tracing() {
8657 }
8658
8659 static final private void jj_rescan_token() {
8660 jj_rescan = true;
8661 for (int i = 0; i < 19; i++) {
8662 JJCalls p = jj_2_rtns[i];
8663 do {
8664 if (p.gen > jj_gen) {
8665 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
8666 switch (i) {
8667 case 0: jj_3_1(); break;
8668 case 1: jj_3_2(); break;
8669 case 2: jj_3_3(); break;
8670 case 3: jj_3_4(); break;
8671 case 4: jj_3_5(); break;
8672 case 5: jj_3_6(); break;
8673 case 6: jj_3_7(); break;
8674 case 7: jj_3_8(); break;
8675 case 8: jj_3_9(); break;
8676 case 9: jj_3_10(); break;
8677 case 10: jj_3_11(); break;
8678 case 11: jj_3_12(); break;
8679 case 12: jj_3_13(); break;
8680 case 13: jj_3_14(); break;
8681 case 14: jj_3_15(); break;
8682 case 15: jj_3_16(); break;
8683 case 16: jj_3_17(); break;
8684 case 17: jj_3_18(); break;
8685 case 18: jj_3_19(); break;
8686 }
8687 }
8688 p = p.next;
8689 } while (p != null);
8690 }
8691 jj_rescan = false;
8692 }
8693
8694 static final private void jj_save(int index, int xla) {
8695 JJCalls p = jj_2_rtns[index];
8696 while (p.gen > jj_gen) {
8697 if (p.next == null) { p = p.next = new JJCalls(); break; }
8698 p = p.next;
8699 }
8700 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
8701 }
8702
8703 static final class JJCalls {
8704 int gen;
8705 Token first;
8706 int arg;
8707 JJCalls next;
8708 }
8709
8710 }
This page was automatically generated by Maven